fit_sdk/
value.rs

1/// The container type for the different values.
2#[derive(Clone)]
3pub enum Value {
4    Enum(u8),
5    String(String),
6    U8(u8),
7    U16(u16),
8    U32(u32),
9    U64(u64),
10    I8(i8),
11    I16(i16),
12    I32(i32),
13    I64(i64),
14    F32(f32),
15    F64(f64),
16    Time(u32),
17    Array(Vec<Value>),
18}
19
20impl Value {
21    pub fn scale(self, s: Option<f64>) -> Self {
22        match s {
23            None => self,
24            Some(rhs) => match self {
25                Value::U8(v) => Value::F64(f64::from(v) / rhs),
26                Value::U16(v) => Value::F64(f64::from(v) / rhs),
27                Value::U32(v) => Value::F64(f64::from(v) / rhs),
28                Value::U64(v) => Value::F64(v as f64 / rhs),
29                Value::I8(v) => Value::F64(f64::from(v) / rhs),
30                Value::I16(v) => Value::F64(f64::from(v) / rhs),
31                Value::I32(v) => Value::F64(f64::from(v) / rhs),
32                Value::I64(v) => Value::F64(v as f64 / rhs),
33                Value::F32(v) => Value::F64(f64::from(v) / rhs),
34                Value::F64(v) => Value::F64(v / rhs),
35                _ => self,
36            },
37        }
38    }
39    pub fn offset(self, o: Option<f64>) -> Self {
40        match o {
41            None => self,
42            Some(rhs) => match self {
43                Value::U8(v) => Value::F64(f64::from(v) - rhs),
44                Value::U16(v) => Value::F64(f64::from(v) - rhs),
45                Value::U32(v) => Value::F64(f64::from(v) - rhs),
46                Value::U64(v) => Value::F64(v as f64 - rhs),
47                Value::I8(v) => Value::F64(f64::from(v) - rhs),
48                Value::I16(v) => Value::F64(f64::from(v) - rhs),
49                Value::I32(v) => Value::F64(f64::from(v) - rhs),
50                Value::I64(v) => Value::F64(v as f64 - rhs),
51                Value::F32(v) => Value::F64(f64::from(v) - rhs),
52                Value::F64(v) => Value::F64(v - rhs),
53                _ => self,
54            },
55        }
56    }
57
58    pub fn u8(&self) -> u8 {
59        if let Value::U8(i) = self {
60            *i
61        } else {
62            panic!("not a u8")
63        }
64    }
65}
66
67impl PartialEq for Value {
68    fn eq(&self, other: &Value) -> bool {
69        match self {
70            Value::U8(v) => {
71                if let Value::U8(ov) = other {
72                    v == ov
73                } else {
74                    panic!("failed comparing U8 {:?} with {:?}", self, other)
75                }
76            }
77            Value::U16(v) => {
78                if let Value::U16(ov) = other {
79                    v == ov
80                } else {
81                    panic!("failed comparing U16 {:?} with {:?}", self, other)
82                }
83            }
84            Value::U32(v) => {
85                if let Value::U32(ov) = other {
86                    v == ov
87                } else {
88                    panic!("failed comparing U32 {:?} with {:?}", self, other)
89                }
90            }
91            Value::U64(v) => {
92                if let Value::U64(ov) = other {
93                    v == ov
94                } else {
95                    panic!("failed comparing U64 {:?} with {:?}", self, other)
96                }
97            }
98            Value::I8(v) => {
99                if let Value::I8(ov) = other {
100                    v == ov
101                } else {
102                    panic!("failed comparing I8 {:?} with {:?}", self, other)
103                }
104            }
105            Value::I16(v) => {
106                if let Value::I16(ov) = other {
107                    v == ov
108                } else {
109                    panic!("failed comparing I16 {:?} with {:?}", self, other)
110                }
111            }
112            Value::I32(v) => {
113                if let Value::I32(ov) = other {
114                    v == ov
115                } else {
116                    panic!("failed comparing I32 {:?} with {:?}", self, other)
117                }
118            }
119            Value::I64(v) => {
120                if let Value::I64(ov) = other {
121                    v == ov
122                } else {
123                    panic!("failed comparing I64 {:?} with {:?}", self, other)
124                }
125            }
126            Value::F32(v) => match other {
127                Value::U32(ov) => {
128                    let f = *ov as f32;
129                    *v == f
130                }
131                Value::F32(f) => v == f,
132                _ => panic!("failed comparing F32 {:?} with {:?}", self, other),
133            },
134            Value::F64(v) => match other {
135                Value::U64(ov) => {
136                    let f = *ov as f64;
137                    *v == f
138                }
139                Value::F64(f) => v == f,
140                _ => panic!("failed comparing F64 {:?} with {:?}", self, other),
141            },
142            Value::Time(v) => {
143                if let Value::Time(ov) = other {
144                    v == ov
145                } else {
146                    panic!("failed comparing Time {:?} with {:?}", self, other)
147                }
148            }
149            Value::String(v) => {
150                if let Value::String(ov) = other {
151                    v == ov
152                } else {
153                    panic!("failed comparing Str {:?} with {:?}", self, other)
154                }
155            }
156            Value::Enum(v) => {
157                if let Value::Enum(ov) = other {
158                    v == ov
159                } else {
160                    panic!("failed comparing Enum {:?} with {:?}", self, other)
161                }
162            }
163            Value::Array(_v) => true,
164        }
165    }
166}
167
168impl std::fmt::Display for Value {
169    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
170        match self {
171            Value::U8(v) => write!(f, "{}", v),
172            Value::U16(v) => write!(f, "{}", v),
173            Value::U32(v) => write!(f, "{}", v),
174            Value::U64(v) => write!(f, "{}", v),
175            Value::I8(v) => write!(f, "{}", v),
176            Value::I16(v) => write!(f, "{}", v),
177            Value::I32(v) => write!(f, "{}", v),
178            Value::I64(v) => write!(f, "{}", v),
179            Value::F32(v) => write!(f, "{}", v),
180            Value::F64(v) => write!(f, "{}", v),
181            Value::Time(v) => write!(f, "{}", v),
182            Value::String(v) => write!(f, "\"{}\"", v),
183            Value::Enum(v) => write!(f, "\"{}\"", v),
184            Value::Array(v) => write!(f, "\"{:?}\"", v),
185        }
186    }
187}
188impl std::fmt::Debug for Value {
189    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
190        match self {
191            Value::U8(v) => write!(f, "{} /u8", v),
192            Value::U16(v) => write!(f, "{} /u16", v),
193            Value::U32(v) => write!(f, "{} /u32", v),
194            Value::U64(v) => write!(f, "{} /u64", v),
195            Value::I8(v) => write!(f, "{} /i8", v),
196            Value::I16(v) => write!(f, "{} /i16", v),
197            Value::I32(v) => write!(f, "{} /i32", v),
198            Value::I64(v) => write!(f, "{} /i64", v),
199            Value::F32(v) => write!(f, "{} /f32", v),
200            Value::F64(v) => write!(f, "{} /f64", v),
201            Value::Time(v) => write!(f, "{} /time", v),
202            Value::String(v) => write!(f, "\"{}\" /str", v),
203            Value::Enum(v) => write!(f, "\"{}\" /enum", v),
204            Value::Array(v) => write!(f, "\"{:?}\" /arr", v),
205        }
206    }
207}
208
209impl From<u8> for Value {
210    fn from(f: u8) -> Self {
211        Value::U8(f)
212    }
213}
214impl From<u16> for Value {
215    fn from(f: u16) -> Self {
216        Value::U16(f)
217    }
218}
219impl From<u32> for Value {
220    fn from(f: u32) -> Self {
221        Value::U32(f)
222    }
223}
224impl From<u64> for Value {
225    fn from(f: u64) -> Self {
226        Value::U64(f)
227    }
228}
229impl From<i8> for Value {
230    fn from(f: i8) -> Self {
231        Value::I8(f)
232    }
233}
234impl From<i16> for Value {
235    fn from(f: i16) -> Self {
236        Value::I16(f)
237    }
238}
239impl From<i32> for Value {
240    fn from(f: i32) -> Self {
241        Value::I32(f)
242    }
243}
244impl From<i64> for Value {
245    fn from(f: i64) -> Self {
246        Value::I64(f)
247    }
248}
249impl From<f32> for Value {
250    fn from(f: f32) -> Self {
251        Value::F32(f)
252    }
253}
254impl From<f64> for Value {
255    fn from(f: f64) -> Self {
256        Value::F64(f)
257    }
258}
259impl From<&str> for Value {
260    fn from(f: &str) -> Self {
261        Value::String(f.to_owned())
262    }
263}
264impl From<String> for Value {
265    fn from(f: String) -> Self {
266        Value::String(f)
267    }
268}
269impl From<&[Value]> for Value {
270    fn from(v: &[Value]) -> Self {
271        Value::Array(v.to_vec())
272    }
273}
274impl From<Vec<Value>> for Value {
275    fn from(v: Vec<Value>) -> Self {
276        Value::Array(v)
277    }
278}
fit_sdk/value.rs

fit_sdk/
value.rs
