ble_data_struct/data_types/tx_power_level.rs
1//! Tx Power Level (Data Type Value: 0x0a) module.
2
3use crate::data_types::data_type::DataType;
4
5/// Tx Power Level.
6#[derive(Debug, PartialEq, Clone)]
7pub struct TxPowerLevel {
8 /// data length
9 pub length: u8,
10
11 /// Tx Power Level
12 pub tx_power_level: i8,
13}
14
15impl TxPowerLevel {
16 /// Create [`TxPowerLevel`] from `Tx Power Level`.
17 ///
18 /// # Examples
19 ///
20 /// ```
21 /// use ble_data_struct::data_types::tx_power_level::TxPowerLevel;
22 ///
23 /// let tx_power_level = -127;
24 /// let result = TxPowerLevel::new(tx_power_level);
25 /// assert_eq!(2, result.length);
26 /// assert_eq!(tx_power_level, result.tx_power_level);
27 ///
28 /// let tx_power_level = 127;
29 /// let result = TxPowerLevel::new(tx_power_level);
30 /// assert_eq!(2, result.length);
31 /// assert_eq!(tx_power_level, result.tx_power_level);
32 /// ```
33 pub fn new(tx_power_level: i8) -> Self {
34 Self {
35 length: 2,
36 tx_power_level,
37 }
38 }
39}
40
41impl TryFrom<&Vec<u8>> for TxPowerLevel {
42 type Error = String;
43 /// Create [`TxPowerLevel`] from [`Vec<u8>`].
44 ///
45 /// # Examples
46 ///
47 /// ```
48 /// use ble_data_struct::data_types::{tx_power_level::TxPowerLevel, data_type::DataType};
49 ///
50 /// let tx_power_level = -127;
51 /// let length = 2;
52 /// let mut data: Vec<u8> = Vec::new();
53 /// data.push(length);
54 /// data.push(TxPowerLevel::data_type());
55 /// data.push(tx_power_level as u8);
56 ///
57 /// let result = TxPowerLevel::try_from(&data);
58 /// assert!(result.is_ok());
59 /// let data_type = result.unwrap();
60 /// assert_eq!(length, data_type.length);
61 /// assert_eq!(tx_power_level, data_type.tx_power_level);
62 ///
63 /// let tx_power_level = 127;
64 /// let length = 2;
65 /// let mut data: Vec<u8> = Vec::new();
66 /// data.push(length);
67 /// data.push(TxPowerLevel::data_type());
68 /// data.push(tx_power_level as u8);
69 ///
70 /// let result = TxPowerLevel::try_from(&data);
71 /// assert!(result.is_ok());
72 /// let data_type = result.unwrap();
73 /// assert_eq!(length, data_type.length);
74 /// assert_eq!(tx_power_level, data_type.tx_power_level);
75 ///
76 /// let data: Vec<u8> = Vec::new();
77 /// let result = TxPowerLevel::try_from(&data);
78 /// assert!(result.is_err());
79 /// assert_eq!(
80 /// format!("Invalid data size :{}", data.len()),
81 /// result.unwrap_err()
82 /// );
83 /// ```
84 fn try_from(value: &Vec<u8>) -> Result<Self, String> {
85 let len = value.len();
86 if len < 3 {
87 return Err(format!("Invalid data size :{}", len).to_string());
88 }
89 let length = value[0];
90 Ok(Self {
91 length,
92 tx_power_level: value[2] as i8,
93 })
94 }
95}
96
97impl Into<Vec<u8>> for TxPowerLevel {
98 /// Create [`Vec<u8>`] from [`TxPowerLevel`].
99 ///
100 /// # Examples
101 ///
102 /// ```
103 /// use ble_data_struct::data_types::{tx_power_level::TxPowerLevel, data_type::DataType};
104 ///
105 /// let tx_power_level = -127;
106 /// let result1 = TxPowerLevel::new(tx_power_level);
107 ///
108 /// let mut data: Vec<u8> = Vec::new();
109 /// data.push(2);
110 /// data.push(TxPowerLevel::data_type());
111 /// data.push(tx_power_level as u8);
112 ///
113 /// let into_data: Vec<u8> = result1.into();
114 /// assert_eq!(data, into_data);
115 ///
116 /// let result2 = TxPowerLevel::try_from(&data);
117 /// assert!(result2.is_ok());
118 /// let data_type = result2.unwrap();
119 /// let into_data: Vec<u8> = data_type.into();
120 /// assert_eq!(data, into_data);
121 ///
122 /// let tx_power_level = 127;
123 /// let result1 = TxPowerLevel::new(tx_power_level);
124 ///
125 /// let mut data: Vec<u8> = Vec::new();
126 /// data.push(2);
127 /// data.push(TxPowerLevel::data_type());
128 /// data.push(tx_power_level as u8);
129 ///
130 /// let into_data: Vec<u8> = result1.into();
131 /// assert_eq!(data, into_data);
132 ///
133 /// let result2 = TxPowerLevel::try_from(&data);
134 /// assert!(result2.is_ok());
135 /// let data_type = result2.unwrap();
136 /// let into_data: Vec<u8> = data_type.into();
137 /// assert_eq!(data, into_data);
138 /// ```
139 fn into(self) -> Vec<u8> {
140 let mut data: Vec<u8> = Vec::new();
141 data.push(self.length);
142 data.push(Self::data_type());
143 data.push(self.tx_power_level as u8);
144 return data;
145 }
146}
147
148impl DataType for TxPowerLevel {
149 /// return `0x0a`.
150 ///
151 /// # Examples
152 ///
153 /// ```
154 /// use ble_data_struct::data_types::{tx_power_level::TxPowerLevel, data_type::DataType};
155 ///
156 /// assert_eq!(0x0a, TxPowerLevel::data_type());
157 /// ```
158 fn data_type() -> u8 {
159 0x0a
160 }
161}
162
163/// check `Tx Power Level` data type.
164///
165/// # Examples
166///
167/// ```
168/// use ble_data_struct::data_types::tx_power_level::*;
169/// use ble_data_struct::data_types::data_type::DataType;
170///
171/// assert!(is_tx_power_level(0x0a));
172/// assert!(!is_tx_power_level(0x00));
173/// ```
174pub fn is_tx_power_level(data_type: u8) -> bool {
175 TxPowerLevel::data_type() == data_type
176}
177
178#[cfg(test)]
179mod tests {
180 use crate::data_types::{data_type::DataType, tx_power_level::*};
181
182 #[test]
183 fn test_new() {
184 let tx_power_level = -127;
185 let result = TxPowerLevel::new(tx_power_level);
186 assert_eq!(2, result.length);
187 assert_eq!(tx_power_level, result.tx_power_level);
188
189 let tx_power_level = 127;
190 let result = TxPowerLevel::new(tx_power_level);
191 assert_eq!(2, result.length);
192 assert_eq!(tx_power_level, result.tx_power_level);
193 }
194
195 #[test]
196 fn test_try_from() {
197 let tx_power_level = -127;
198 let length = 2;
199 let mut data: Vec<u8> = Vec::new();
200 data.push(length);
201 data.push(TxPowerLevel::data_type());
202 data.push(tx_power_level as u8);
203
204 let result = TxPowerLevel::try_from(&data);
205 assert!(result.is_ok());
206 let data_type = result.unwrap();
207 assert_eq!(length, data_type.length);
208 assert_eq!(tx_power_level, data_type.tx_power_level);
209
210 let tx_power_level = 127;
211 let length = 2;
212 let mut data: Vec<u8> = Vec::new();
213 data.push(length);
214 data.push(TxPowerLevel::data_type());
215 data.push(tx_power_level as u8);
216
217 let result = TxPowerLevel::try_from(&data);
218 assert!(result.is_ok());
219 let data_type = result.unwrap();
220 assert_eq!(length, data_type.length);
221 assert_eq!(tx_power_level, data_type.tx_power_level);
222
223 let mut data: Vec<u8> = vec![0u8; 2];
224 data[0] = data.len() as u8 - 1;
225 let result = TxPowerLevel::try_from(&data);
226 assert!(result.is_err());
227 assert_eq!(
228 format!("Invalid data size :{}", data.len()),
229 result.unwrap_err()
230 );
231 }
232
233 #[test]
234 fn test_into() {
235 let tx_power_level = -127;
236 let result1 = TxPowerLevel::new(tx_power_level);
237
238 let mut data: Vec<u8> = Vec::new();
239 data.push(2);
240 data.push(TxPowerLevel::data_type());
241 data.push(tx_power_level as u8);
242
243 let into_data: Vec<u8> = result1.into();
244 assert_eq!(data, into_data);
245
246 let result2 = TxPowerLevel::try_from(&data);
247 assert!(result2.is_ok());
248 let data_type = result2.unwrap();
249 let into_data: Vec<u8> = data_type.into();
250 assert_eq!(data, into_data);
251
252 let tx_power_level = 127;
253 let result1 = TxPowerLevel::new(tx_power_level);
254
255 let mut data: Vec<u8> = Vec::new();
256 data.push(2);
257 data.push(TxPowerLevel::data_type());
258 data.push(tx_power_level as u8);
259
260 let into_data: Vec<u8> = result1.into();
261 assert_eq!(data, into_data);
262
263 let result2 = TxPowerLevel::try_from(&data);
264 assert!(result2.is_ok());
265 let data_type = result2.unwrap();
266 let into_data: Vec<u8> = data_type.into();
267 assert_eq!(data, into_data);
268 }
269
270 #[test]
271 fn test_data_type() {
272 assert_eq!(0x0a, TxPowerLevel::data_type());
273 }
274
275 #[test]
276 fn test_is_tx_power_level() {
277 assert!(is_tx_power_level(0x0a));
278 assert!(!is_tx_power_level(0x00));
279 }
280}