tinkerforge/
byte_converter.rs

1//! Traits for (de)serialization of structs to byte vectors.
2use crate::converting_receiver::BrickletError;
3use byteorder::*;
4
5/// A trait to serialize the implementing type to a byte vector.
6pub trait ToBytes {
7    /// Serialize the implementing type to a byte vector.
8    fn to_le_byte_vec(_: Self) -> Vec<u8>;
9
10    /// Try to serialize the implementing type to a byte vector. If the type is shorter than max_len, it will be padded with zero bytes. Currently this method is only used for strings. Other types use the standard implementation, which calls [`to_le_byte_vec`] without further checks or padding.
11    /// # Errors
12    /// Returns an InvalidArgument error if the type was too long.
13    ///
14    /// [`to_le_byte_vec`]: #ToBytes.to_le_byte_vec
15    fn try_to_le_byte_vec(var: Self, _max_len: usize) -> Result<Vec<u8>, BrickletError>
16    where
17        Self: std::marker::Sized,
18    {
19        Ok(Self::to_le_byte_vec(var))
20    }
21}
22
23/// A trait to deserialize the implemeting type from a byte slice.
24pub trait FromByteSlice {
25    /// Deserialize the implementing type from a byte slice.
26    fn from_le_byte_slice(bytes: &[u8]) -> Self;
27    /// Returns how many bytes are expected to deserialize a instance of the implementing type. Currently this method is only used for strings.
28    fn bytes_expected() -> usize;
29}
30
31impl ToBytes for () {
32    fn to_le_byte_vec(_: ()) -> Vec<u8> { vec![] }
33}
34
35impl FromByteSlice for () {
36    fn from_le_byte_slice(_: &[u8]) {}
37
38    fn bytes_expected() -> usize { 0 }
39}
40
41impl ToBytes for bool {
42    fn to_le_byte_vec(b: bool) -> Vec<u8> { vec![b as u8] }
43}
44
45impl FromByteSlice for bool {
46    fn from_le_byte_slice(bytes: &[u8]) -> bool { bytes[0] != 0 }
47
48    fn bytes_expected() -> usize { 1 }
49}
50
51impl ToBytes for u8 {
52    fn to_le_byte_vec(num: u8) -> Vec<u8> { vec![num] }
53}
54
55impl FromByteSlice for u8 {
56    fn from_le_byte_slice(bytes: &[u8]) -> u8 { bytes[0] }
57
58    fn bytes_expected() -> usize { 1 }
59}
60
61impl ToBytes for i8 {
62    fn to_le_byte_vec(num: i8) -> Vec<u8> { vec![num as u8] }
63}
64
65impl FromByteSlice for i8 {
66    fn from_le_byte_slice(bytes: &[u8]) -> i8 { bytes[0] as i8 }
67
68    fn bytes_expected() -> usize { 1 }
69}
70
71impl ToBytes for u16 {
72    fn to_le_byte_vec(num: u16) -> Vec<u8> {
73        let mut buf = vec![0; 2];
74        LittleEndian::write_u16(&mut buf, num);
75        buf
76    }
77}
78
79impl FromByteSlice for u16 {
80    fn from_le_byte_slice(bytes: &[u8]) -> u16 { LittleEndian::read_u16(bytes) }
81
82    fn bytes_expected() -> usize { 2 }
83}
84
85impl ToBytes for i16 {
86    fn to_le_byte_vec(num: i16) -> Vec<u8> {
87        let mut buf = vec![0; 2];
88        LittleEndian::write_i16(&mut buf, num);
89        buf
90    }
91}
92
93impl FromByteSlice for i16 {
94    fn from_le_byte_slice(bytes: &[u8]) -> i16 { LittleEndian::read_i16(bytes) }
95
96    fn bytes_expected() -> usize { 2 }
97}
98
99impl ToBytes for u32 {
100    fn to_le_byte_vec(num: u32) -> Vec<u8> {
101        let mut buf = vec![0; 4];
102        LittleEndian::write_u32(&mut buf, num);
103        buf
104    }
105}
106
107impl FromByteSlice for u32 {
108    fn from_le_byte_slice(bytes: &[u8]) -> u32 { LittleEndian::read_u32(bytes) }
109
110    fn bytes_expected() -> usize { 4 }
111}
112
113impl ToBytes for i32 {
114    fn to_le_byte_vec(num: i32) -> Vec<u8> {
115        let mut buf = vec![0; 4];
116        LittleEndian::write_i32(&mut buf, num);
117        buf
118    }
119}
120
121impl FromByteSlice for i32 {
122    fn from_le_byte_slice(bytes: &[u8]) -> i32 { LittleEndian::read_i32(bytes) }
123
124    fn bytes_expected() -> usize { 4 }
125}
126
127impl ToBytes for u64 {
128    fn to_le_byte_vec(num: u64) -> Vec<u8> {
129        let mut buf = vec![0; 8];
130        LittleEndian::write_u64(&mut buf, num);
131        buf
132    }
133}
134
135impl FromByteSlice for u64 {
136    fn from_le_byte_slice(bytes: &[u8]) -> u64 { LittleEndian::read_u64(bytes) }
137
138    fn bytes_expected() -> usize { 8 }
139}
140
141impl ToBytes for i64 {
142    fn to_le_byte_vec(num: i64) -> Vec<u8> {
143        let mut buf = vec![0; 8];
144        LittleEndian::write_i64(&mut buf, num);
145        buf
146    }
147}
148
149impl FromByteSlice for i64 {
150    fn from_le_byte_slice(bytes: &[u8]) -> i64 { LittleEndian::read_i64(bytes) }
151
152    fn bytes_expected() -> usize { 8 }
153}
154
155impl ToBytes for char {
156    fn to_le_byte_vec(c: char) -> Vec<u8> { vec![c as u8] }
157}
158
159impl FromByteSlice for char {
160    fn from_le_byte_slice(bytes: &[u8]) -> char { bytes[0] as char }
161
162    fn bytes_expected() -> usize { 1 }
163}
164
165impl ToBytes for String {
166    fn to_le_byte_vec(s: String) -> Vec<u8> { s.into_bytes() }
167
168    fn try_to_le_byte_vec(s: String, max_len: usize) -> Result<Vec<u8>, BrickletError> {
169        if s.chars().any(|c| c as u32 > 255) {
170            return Err(BrickletError::InvalidParameter);
171        }
172        let bytes: Vec<u8> = s.chars().map(|c| c as u8).collect();
173        if bytes.len() > max_len {
174            Err(BrickletError::InvalidParameter)
175        } else {
176            let mut result = vec![0u8; max_len];
177            result[0..bytes.len()].copy_from_slice(&bytes);
178            Ok(result)
179        }
180    }
181}
182
183impl FromByteSlice for String {
184    fn from_le_byte_slice(bytes: &[u8]) -> String { bytes.into_iter().filter(|&&b| b != 0).map(|&b| b as char).collect() }
185
186    fn bytes_expected() -> usize { 1 }
187}
188
189impl ToBytes for f32 {
190    fn to_le_byte_vec(num: f32) -> Vec<u8> {
191        let mut buf = vec![0; 4];
192        LittleEndian::write_f32(&mut buf, num);
193        buf
194    }
195}
196
197impl FromByteSlice for f32 {
198    fn from_le_byte_slice(bytes: &[u8]) -> f32 { LittleEndian::read_f32(bytes) }
199
200    fn bytes_expected() -> usize { 4 }
201}
202
203impl ToBytes for f64 {
204    fn to_le_byte_vec(num: f64) -> Vec<u8> {
205        let mut buf = vec![0; 8];
206        LittleEndian::write_f64(&mut buf, num);
207        buf
208    }
209}
210
211impl FromByteSlice for f64 {
212    fn from_le_byte_slice(bytes: &[u8]) -> f64 { LittleEndian::read_f64(bytes) }
213
214    fn bytes_expected() -> usize { 8 }
215}
216
217impl ToBytes for [bool; 2] {
218    fn to_le_byte_vec(arr: [bool; 2]) -> Vec<u8> {
219        let mut buf = vec![0u8; arr.len() / 8 + if arr.len() % 8 == 0 { 0 } else { 1 }];
220        for (i, b) in arr.into_iter().enumerate() {
221            buf[i / 8] |= (*b as u8) << (i % 8);
222        }
223        buf
224    }
225}
226
227impl FromByteSlice for [bool; 2] {
228    fn from_le_byte_slice(bytes: &[u8]) -> [bool; 2] {
229        let mut result = [false; 2];
230        for (byte, elem) in bytes.into_iter().enumerate() {
231            for i in 0..8 {
232                if byte * 8 + i >= result.len() {
233                    break;
234                }
235                result[byte * 8 + i] = (*elem & 1 << i) > 0;
236            }
237        }
238        result
239    }
240    fn bytes_expected() -> usize { 1 }
241}
242
243impl ToBytes for [bool; 3] {
244    fn to_le_byte_vec(arr: [bool; 3]) -> Vec<u8> {
245        let mut buf = vec![0u8; arr.len() / 8 + if arr.len() % 8 == 0 { 0 } else { 1 }];
246        for (i, b) in arr.into_iter().enumerate() {
247            buf[i / 8] |= (*b as u8) << (i % 8);
248        }
249        buf
250    }
251}
252
253impl FromByteSlice for [bool; 3] {
254    fn from_le_byte_slice(bytes: &[u8]) -> [bool; 3] {
255        let mut result = [false; 3];
256        for (byte, elem) in bytes.into_iter().enumerate() {
257            for i in 0..8 {
258                if byte * 8 + i >= result.len() {
259                    break;
260                }
261                result[byte * 8 + i] = (*elem & 1 << i) > 0;
262            }
263        }
264        result
265    }
266    fn bytes_expected() -> usize { 1 }
267}
268
269impl ToBytes for [bool; 4] {
270    fn to_le_byte_vec(arr: [bool; 4]) -> Vec<u8> {
271        let mut buf = vec![0u8; arr.len() / 8 + if arr.len() % 8 == 0 { 0 } else { 1 }];
272        for (i, b) in arr.into_iter().enumerate() {
273            buf[i / 8] |= (*b as u8) << (i % 8);
274        }
275        buf
276    }
277}
278
279impl FromByteSlice for [bool; 4] {
280    fn from_le_byte_slice(bytes: &[u8]) -> [bool; 4] {
281        let mut result = [false; 4];
282        for (byte, elem) in bytes.into_iter().enumerate() {
283            for i in 0..8 {
284                if byte * 8 + i >= result.len() {
285                    break;
286                }
287                result[byte * 8 + i] = (*elem & 1 << i) > 0;
288            }
289        }
290        result
291    }
292    fn bytes_expected() -> usize { 1 }
293}
294
295impl ToBytes for [bool; 5] {
296    fn to_le_byte_vec(arr: [bool; 5]) -> Vec<u8> {
297        let mut buf = vec![0u8; arr.len() / 8 + if arr.len() % 8 == 0 { 0 } else { 1 }];
298        for (i, b) in arr.into_iter().enumerate() {
299            buf[i / 8] |= (*b as u8) << (i % 8);
300        }
301        buf
302    }
303}
304
305impl FromByteSlice for [bool; 5] {
306    fn from_le_byte_slice(bytes: &[u8]) -> [bool; 5] {
307        let mut result = [false; 5];
308        for (byte, elem) in bytes.into_iter().enumerate() {
309            for i in 0..8 {
310                if byte * 8 + i >= result.len() {
311                    break;
312                }
313                result[byte * 8 + i] = (*elem & 1 << i) > 0;
314            }
315        }
316        result
317    }
318    fn bytes_expected() -> usize { 1 }
319}
320
321impl ToBytes for [bool; 8] {
322    fn to_le_byte_vec(arr: [bool; 8]) -> Vec<u8> {
323        let mut buf = vec![0u8; arr.len() / 8 + if arr.len() % 8 == 0 { 0 } else { 1 }];
324        for (i, b) in arr.into_iter().enumerate() {
325            buf[i / 8] |= (*b as u8) << (i % 8);
326        }
327        buf
328    }
329}
330
331impl FromByteSlice for [bool; 8] {
332    fn from_le_byte_slice(bytes: &[u8]) -> [bool; 8] {
333        let mut result = [false; 8];
334        for (byte, elem) in bytes.into_iter().enumerate() {
335            for i in 0..8 {
336                if byte * 8 + i >= result.len() {
337                    break;
338                }
339                result[byte * 8 + i] = (*elem & 1 << i) > 0;
340            }
341        }
342        result
343    }
344    fn bytes_expected() -> usize { 1 }
345}
346
347impl ToBytes for [bool; 10] {
348    fn to_le_byte_vec(arr: [bool; 10]) -> Vec<u8> {
349        let mut buf = vec![0u8; arr.len() / 8 + if arr.len() % 8 == 0 { 0 } else { 1 }];
350        for (i, b) in arr.into_iter().enumerate() {
351            buf[i / 8] |= (*b as u8) << (i % 8);
352        }
353        buf
354    }
355}
356
357impl FromByteSlice for [bool; 10] {
358    fn from_le_byte_slice(bytes: &[u8]) -> [bool; 10] {
359        let mut result = [false; 10];
360        for (byte, elem) in bytes.into_iter().enumerate() {
361            for i in 0..8 {
362                if byte * 8 + i >= result.len() {
363                    break;
364                }
365                result[byte * 8 + i] = (*elem & 1 << i) > 0;
366            }
367        }
368        result
369    }
370    fn bytes_expected() -> usize { 2 }
371}
372
373impl ToBytes for [bool; 13] {
374    fn to_le_byte_vec(arr: [bool; 13]) -> Vec<u8> {
375        let mut buf = vec![0u8; arr.len() / 8 + if arr.len() % 8 == 0 { 0 } else { 1 }];
376        for (i, b) in arr.into_iter().enumerate() {
377            buf[i / 8] |= (*b as u8) << (i % 8);
378        }
379        buf
380    }
381}
382
383impl FromByteSlice for [bool; 13] {
384    fn from_le_byte_slice(bytes: &[u8]) -> [bool; 13] {
385        let mut result = [false; 13];
386        for (byte, elem) in bytes.into_iter().enumerate() {
387            for i in 0..8 {
388                if byte * 8 + i >= result.len() {
389                    break;
390                }
391                result[byte * 8 + i] = (*elem & 1 << i) > 0;
392            }
393        }
394        result
395    }
396    fn bytes_expected() -> usize { 2 }
397}
398
399impl ToBytes for [bool; 16] {
400    fn to_le_byte_vec(arr: [bool; 16]) -> Vec<u8> {
401        let mut buf = vec![0u8; arr.len() / 8 + if arr.len() % 8 == 0 { 0 } else { 1 }];
402        for (i, b) in arr.into_iter().enumerate() {
403            buf[i / 8] |= (*b as u8) << (i % 8);
404        }
405        buf
406    }
407}
408
409impl FromByteSlice for [bool; 16] {
410    fn from_le_byte_slice(bytes: &[u8]) -> [bool; 16] {
411        let mut result = [false; 16];
412        for (byte, elem) in bytes.into_iter().enumerate() {
413            for i in 0..8 {
414                if byte * 8 + i >= result.len() {
415                    break;
416                }
417                result[byte * 8 + i] = (*elem & 1 << i) > 0;
418            }
419        }
420        result
421    }
422    fn bytes_expected() -> usize { 2 }
423}
424
425impl ToBytes for [bool; 24] {
426    fn to_le_byte_vec(arr: [bool; 24]) -> Vec<u8> {
427        let mut buf = vec![0u8; arr.len() / 8 + if arr.len() % 8 == 0 { 0 } else { 1 }];
428        for (i, b) in arr.into_iter().enumerate() {
429            buf[i / 8] |= (*b as u8) << (i % 8);
430        }
431        buf
432    }
433}
434
435impl FromByteSlice for [bool; 24] {
436    fn from_le_byte_slice(bytes: &[u8]) -> [bool; 24] {
437        let mut result = [false; 24];
438        for (byte, elem) in bytes.into_iter().enumerate() {
439            for i in 0..8 {
440                if byte * 8 + i >= result.len() {
441                    break;
442                }
443                result[byte * 8 + i] = (*elem & 1 << i) > 0;
444            }
445        }
446        result
447    }
448    fn bytes_expected() -> usize { 3 }
449}
450
451impl ToBytes for [bool; 32] {
452    fn to_le_byte_vec(arr: [bool; 32]) -> Vec<u8> {
453        let mut buf = vec![0u8; arr.len() / 8 + if arr.len() % 8 == 0 { 0 } else { 1 }];
454        for (i, b) in arr.into_iter().enumerate() {
455            buf[i / 8] |= (*b as u8) << (i % 8);
456        }
457        buf
458    }
459}
460
461impl FromByteSlice for [bool; 32] {
462    fn from_le_byte_slice(bytes: &[u8]) -> [bool; 32] {
463        let mut result = [false; 32];
464        for (byte, elem) in bytes.into_iter().enumerate() {
465            for i in 0..8 {
466                if byte * 8 + i >= result.len() {
467                    break;
468                }
469                result[byte * 8 + i] = (*elem & 1 << i) > 0;
470            }
471        }
472        result
473    }
474    fn bytes_expected() -> usize { 4 }
475}
476
477impl ToBytes for [bool; 168] {
478    fn to_le_byte_vec(arr: [bool; 168]) -> Vec<u8> {
479        let mut buf = vec![0u8; arr.len() / 8 + if arr.len() % 8 == 0 { 0 } else { 1 }];
480        for (i, b) in arr.into_iter().enumerate() {
481            buf[i / 8] |= (*b as u8) << (i % 8);
482        }
483        buf
484    }
485}
486
487impl FromByteSlice for [bool; 168] {
488    fn from_le_byte_slice(bytes: &[u8]) -> [bool; 168] {
489        let mut result = [false; 168];
490        for (byte, elem) in bytes.into_iter().enumerate() {
491            for i in 0..8 {
492                if byte * 8 + i >= result.len() {
493                    break;
494                }
495                result[byte * 8 + i] = (*elem & 1 << i) > 0;
496            }
497        }
498        result
499    }
500    fn bytes_expected() -> usize { 21 }
501}
502
503impl ToBytes for [bool; 432] {
504    fn to_le_byte_vec(arr: [bool; 432]) -> Vec<u8> {
505        let mut buf = vec![0u8; arr.len() / 8 + if arr.len() % 8 == 0 { 0 } else { 1 }];
506        for (i, b) in arr.into_iter().enumerate() {
507            buf[i / 8] |= (*b as u8) << (i % 8);
508        }
509        buf
510    }
511}
512
513impl FromByteSlice for [bool; 432] {
514    fn from_le_byte_slice(bytes: &[u8]) -> [bool; 432] {
515        let mut result = [false; 432];
516        for (byte, elem) in bytes.into_iter().enumerate() {
517            for i in 0..8 {
518                if byte * 8 + i >= result.len() {
519                    break;
520                }
521                result[byte * 8 + i] = (*elem & 1 << i) > 0;
522            }
523        }
524        result
525    }
526    fn bytes_expected() -> usize { 54 }
527}
528
529impl ToBytes for [bool; 440] {
530    fn to_le_byte_vec(arr: [bool; 440]) -> Vec<u8> {
531        let mut buf = vec![0u8; arr.len() / 8 + if arr.len() % 8 == 0 { 0 } else { 1 }];
532        for (i, b) in arr.into_iter().enumerate() {
533            buf[i / 8] |= (*b as u8) << (i % 8);
534        }
535        buf
536    }
537}
538
539impl FromByteSlice for [bool; 440] {
540    fn from_le_byte_slice(bytes: &[u8]) -> [bool; 440] {
541        let mut result = [false; 440];
542        for (byte, elem) in bytes.into_iter().enumerate() {
543            for i in 0..8 {
544                if byte * 8 + i >= result.len() {
545                    break;
546                }
547                result[byte * 8 + i] = (*elem & 1 << i) > 0;
548            }
549        }
550        result
551    }
552    fn bytes_expected() -> usize { 55 }
553}
554
555impl ToBytes for [bool; 448] {
556    fn to_le_byte_vec(arr: [bool; 448]) -> Vec<u8> {
557        let mut buf = vec![0u8; arr.len() / 8 + if arr.len() % 8 == 0 { 0 } else { 1 }];
558        for (i, b) in arr.into_iter().enumerate() {
559            buf[i / 8] |= (*b as u8) << (i % 8);
560        }
561        buf
562    }
563}
564
565impl FromByteSlice for [bool; 448] {
566    fn from_le_byte_slice(bytes: &[u8]) -> [bool; 448] {
567        let mut result = [false; 448];
568        for (byte, elem) in bytes.into_iter().enumerate() {
569            for i in 0..8 {
570                if byte * 8 + i >= result.len() {
571                    break;
572                }
573                result[byte * 8 + i] = (*elem & 1 << i) > 0;
574            }
575        }
576        result
577    }
578    fn bytes_expected() -> usize { 56 }
579}
580
581impl ToBytes for [bool; 464] {
582    fn to_le_byte_vec(arr: [bool; 464]) -> Vec<u8> {
583        let mut buf = vec![0u8; arr.len() / 8 + if arr.len() % 8 == 0 { 0 } else { 1 }];
584        for (i, b) in arr.into_iter().enumerate() {
585            buf[i / 8] |= (*b as u8) << (i % 8);
586        }
587        buf
588    }
589}
590
591impl FromByteSlice for [bool; 464] {
592    fn from_le_byte_slice(bytes: &[u8]) -> [bool; 464] {
593        let mut result = [false; 464];
594        for (byte, elem) in bytes.into_iter().enumerate() {
595            for i in 0..8 {
596                if byte * 8 + i >= result.len() {
597                    break;
598                }
599                result[byte * 8 + i] = (*elem & 1 << i) > 0;
600            }
601        }
602        result
603    }
604    fn bytes_expected() -> usize { 58 }
605}
606
607impl ToBytes for [bool; 472] {
608    fn to_le_byte_vec(arr: [bool; 472]) -> Vec<u8> {
609        let mut buf = vec![0u8; arr.len() / 8 + if arr.len() % 8 == 0 { 0 } else { 1 }];
610        for (i, b) in arr.into_iter().enumerate() {
611            buf[i / 8] |= (*b as u8) << (i % 8);
612        }
613        buf
614    }
615}
616
617impl FromByteSlice for [bool; 472] {
618    fn from_le_byte_slice(bytes: &[u8]) -> [bool; 472] {
619        let mut result = [false; 472];
620        for (byte, elem) in bytes.into_iter().enumerate() {
621            for i in 0..8 {
622                if byte * 8 + i >= result.len() {
623                    break;
624                }
625                result[byte * 8 + i] = (*elem & 1 << i) > 0;
626            }
627        }
628        result
629    }
630    fn bytes_expected() -> usize { 59 }
631}
632
633impl ToBytes for [bool; 480] {
634    fn to_le_byte_vec(arr: [bool; 480]) -> Vec<u8> {
635        let mut buf = vec![0u8; arr.len() / 8 + if arr.len() % 8 == 0 { 0 } else { 1 }];
636        for (i, b) in arr.into_iter().enumerate() {
637            buf[i / 8] |= (*b as u8) << (i % 8);
638        }
639        buf
640    }
641}
642
643impl FromByteSlice for [bool; 480] {
644    fn from_le_byte_slice(bytes: &[u8]) -> [bool; 480] {
645        let mut result = [false; 480];
646        for (byte, elem) in bytes.into_iter().enumerate() {
647            for i in 0..8 {
648                if byte * 8 + i >= result.len() {
649                    break;
650                }
651                result[byte * 8 + i] = (*elem & 1 << i) > 0;
652            }
653        }
654        result
655    }
656    fn bytes_expected() -> usize { 60 }
657}
658
659impl ToBytes for [u8; 3] {
660    fn to_le_byte_vec(arr: [u8; 3]) -> Vec<u8> { arr.to_vec() }
661}
662
663impl FromByteSlice for [u8; 3] {
664    fn from_le_byte_slice(bytes: &[u8]) -> [u8; 3] {
665        let mut buf = [0u8; 3];
666        buf.copy_from_slice(bytes);
667        buf
668    }
669    fn bytes_expected() -> usize { 3 }
670}
671
672impl ToBytes for [u8; 4] {
673    fn to_le_byte_vec(arr: [u8; 4]) -> Vec<u8> { arr.to_vec() }
674}
675
676impl FromByteSlice for [u8; 4] {
677    fn from_le_byte_slice(bytes: &[u8]) -> [u8; 4] {
678        let mut buf = [0u8; 4];
679        buf.copy_from_slice(bytes);
680        buf
681    }
682    fn bytes_expected() -> usize { 4 }
683}
684
685impl ToBytes for [u8; 6] {
686    fn to_le_byte_vec(arr: [u8; 6]) -> Vec<u8> { arr.to_vec() }
687}
688
689impl FromByteSlice for [u8; 6] {
690    fn from_le_byte_slice(bytes: &[u8]) -> [u8; 6] {
691        let mut buf = [0u8; 6];
692        buf.copy_from_slice(bytes);
693        buf
694    }
695    fn bytes_expected() -> usize { 6 }
696}
697
698impl ToBytes for [u8; 7] {
699    fn to_le_byte_vec(arr: [u8; 7]) -> Vec<u8> { arr.to_vec() }
700}
701
702impl FromByteSlice for [u8; 7] {
703    fn from_le_byte_slice(bytes: &[u8]) -> [u8; 7] {
704        let mut buf = [0u8; 7];
705        buf.copy_from_slice(bytes);
706        buf
707    }
708    fn bytes_expected() -> usize { 7 }
709}
710
711impl ToBytes for [u8; 8] {
712    fn to_le_byte_vec(arr: [u8; 8]) -> Vec<u8> { arr.to_vec() }
713}
714
715impl FromByteSlice for [u8; 8] {
716    fn from_le_byte_slice(bytes: &[u8]) -> [u8; 8] {
717        let mut buf = [0u8; 8];
718        buf.copy_from_slice(bytes);
719        buf
720    }
721    fn bytes_expected() -> usize { 8 }
722}
723
724impl ToBytes for [u8; 10] {
725    fn to_le_byte_vec(arr: [u8; 10]) -> Vec<u8> { arr.to_vec() }
726}
727
728impl FromByteSlice for [u8; 10] {
729    fn from_le_byte_slice(bytes: &[u8]) -> [u8; 10] {
730        let mut buf = [0u8; 10];
731        buf.copy_from_slice(bytes);
732        buf
733    }
734    fn bytes_expected() -> usize { 10 }
735}
736
737impl ToBytes for [u8; 12] {
738    fn to_le_byte_vec(arr: [u8; 12]) -> Vec<u8> { arr.to_vec() }
739}
740
741impl FromByteSlice for [u8; 12] {
742    fn from_le_byte_slice(bytes: &[u8]) -> [u8; 12] {
743        let mut buf = [0u8; 12];
744        buf.copy_from_slice(bytes);
745        buf
746    }
747    fn bytes_expected() -> usize { 12 }
748}
749
750impl ToBytes for [u8; 15] {
751    fn to_le_byte_vec(arr: [u8; 15]) -> Vec<u8> { arr.to_vec() }
752}
753
754impl FromByteSlice for [u8; 15] {
755    fn from_le_byte_slice(bytes: &[u8]) -> [u8; 15] {
756        let mut buf = [0u8; 15];
757        buf.copy_from_slice(bytes);
758        buf
759    }
760    fn bytes_expected() -> usize { 15 }
761}
762
763impl ToBytes for [u8; 16] {
764    fn to_le_byte_vec(arr: [u8; 16]) -> Vec<u8> { arr.to_vec() }
765}
766
767impl FromByteSlice for [u8; 16] {
768    fn from_le_byte_slice(bytes: &[u8]) -> [u8; 16] {
769        let mut buf = [0u8; 16];
770        buf.copy_from_slice(bytes);
771        buf
772    }
773    fn bytes_expected() -> usize { 16 }
774}
775
776impl ToBytes for [u8; 20] {
777    fn to_le_byte_vec(arr: [u8; 20]) -> Vec<u8> { arr.to_vec() }
778}
779
780impl FromByteSlice for [u8; 20] {
781    fn from_le_byte_slice(bytes: &[u8]) -> [u8; 20] {
782        let mut buf = [0u8; 20];
783        buf.copy_from_slice(bytes);
784        buf
785    }
786    fn bytes_expected() -> usize { 20 }
787}
788
789impl ToBytes for [u8; 32] {
790    fn to_le_byte_vec(arr: [u8; 32]) -> Vec<u8> { arr.to_vec() }
791}
792
793impl FromByteSlice for [u8; 32] {
794    fn from_le_byte_slice(bytes: &[u8]) -> [u8; 32] {
795        let mut buf = [0u8; 32];
796        buf.copy_from_slice(bytes);
797        buf
798    }
799    fn bytes_expected() -> usize { 32 }
800}
801
802impl ToBytes for [u8; 52] {
803    fn to_le_byte_vec(arr: [u8; 52]) -> Vec<u8> { arr.to_vec() }
804}
805
806impl FromByteSlice for [u8; 52] {
807    fn from_le_byte_slice(bytes: &[u8]) -> [u8; 52] {
808        let mut buf = [0u8; 52];
809        buf.copy_from_slice(bytes);
810        buf
811    }
812    fn bytes_expected() -> usize { 52 }
813}
814
815impl ToBytes for [u8; 56] {
816    fn to_le_byte_vec(arr: [u8; 56]) -> Vec<u8> { arr.to_vec() }
817}
818
819impl FromByteSlice for [u8; 56] {
820    fn from_le_byte_slice(bytes: &[u8]) -> [u8; 56] {
821        let mut buf = [0u8; 56];
822        buf.copy_from_slice(bytes);
823        buf
824    }
825    fn bytes_expected() -> usize { 56 }
826}
827
828impl ToBytes for [u8; 58] {
829    fn to_le_byte_vec(arr: [u8; 58]) -> Vec<u8> { arr.to_vec() }
830}
831
832impl FromByteSlice for [u8; 58] {
833    fn from_le_byte_slice(bytes: &[u8]) -> [u8; 58] {
834        let mut buf = [0u8; 58];
835        buf.copy_from_slice(bytes);
836        buf
837    }
838    fn bytes_expected() -> usize { 58 }
839}
840
841impl ToBytes for [u8; 59] {
842    fn to_le_byte_vec(arr: [u8; 59]) -> Vec<u8> { arr.to_vec() }
843}
844
845impl FromByteSlice for [u8; 59] {
846    fn from_le_byte_slice(bytes: &[u8]) -> [u8; 59] {
847        let mut buf = [0u8; 59];
848        buf.copy_from_slice(bytes);
849        buf
850    }
851    fn bytes_expected() -> usize { 59 }
852}
853
854impl ToBytes for [u8; 60] {
855    fn to_le_byte_vec(arr: [u8; 60]) -> Vec<u8> { arr.to_vec() }
856}
857
858impl FromByteSlice for [u8; 60] {
859    fn from_le_byte_slice(bytes: &[u8]) -> [u8; 60] {
860        let mut buf = [0u8; 60];
861        buf.copy_from_slice(bytes);
862        buf
863    }
864    fn bytes_expected() -> usize { 60 }
865}
866
867impl ToBytes for [u8; 61] {
868    fn to_le_byte_vec(arr: [u8; 61]) -> Vec<u8> { arr.to_vec() }
869}
870
871impl FromByteSlice for [u8; 61] {
872    fn from_le_byte_slice(bytes: &[u8]) -> [u8; 61] {
873        let mut buf = [0u8; 61];
874        buf.copy_from_slice(bytes);
875        buf
876    }
877    fn bytes_expected() -> usize { 61 }
878}
879
880impl ToBytes for [u8; 62] {
881    fn to_le_byte_vec(arr: [u8; 62]) -> Vec<u8> { arr.to_vec() }
882}
883
884impl FromByteSlice for [u8; 62] {
885    fn from_le_byte_slice(bytes: &[u8]) -> [u8; 62] {
886        let mut buf = [0u8; 62];
887        buf.copy_from_slice(bytes);
888        buf
889    }
890    fn bytes_expected() -> usize { 62 }
891}
892
893impl ToBytes for [u8; 63] {
894    fn to_le_byte_vec(arr: [u8; 63]) -> Vec<u8> { arr.to_vec() }
895}
896
897impl FromByteSlice for [u8; 63] {
898    fn from_le_byte_slice(bytes: &[u8]) -> [u8; 63] {
899        let mut buf = [0u8; 63];
900        buf.copy_from_slice(bytes);
901        buf
902    }
903    fn bytes_expected() -> usize { 63 }
904}
905
906impl ToBytes for [u8; 64] {
907    fn to_le_byte_vec(arr: [u8; 64]) -> Vec<u8> { arr.to_vec() }
908}
909
910impl FromByteSlice for [u8; 64] {
911    fn from_le_byte_slice(bytes: &[u8]) -> [u8; 64] {
912        let mut buf = [0u8; 64];
913        buf.copy_from_slice(bytes);
914        buf
915    }
916    fn bytes_expected() -> usize { 64 }
917}
918
919impl ToBytes for [i8; 4] {
920    fn to_le_byte_vec(arr: [i8; 4]) -> Vec<u8> { vec![arr[0] as u8, arr[1] as u8, arr[2] as u8, arr[3] as u8] }
921}
922
923impl FromByteSlice for [i8; 4] {
924    fn from_le_byte_slice(bytes: &[u8]) -> [i8; 4] { [bytes[0] as i8, bytes[1] as i8, bytes[2] as i8, bytes[3] as i8] }
925    fn bytes_expected() -> usize { 4 }
926}
927
928impl ToBytes for [char; 4] {
929    fn to_le_byte_vec(arr: [char; 4]) -> Vec<u8> { vec![arr[0] as u8, arr[1] as u8, arr[2] as u8, arr[3] as u8] }
930}
931
932impl FromByteSlice for [char; 4] {
933    fn from_le_byte_slice(bytes: &[u8]) -> [char; 4] { [bytes[0] as char, bytes[1] as char, bytes[2] as char, bytes[3] as char] }
934    fn bytes_expected() -> usize { 4 }
935}
936
937impl ToBytes for [char; 5] {
938    fn to_le_byte_vec(arr: [char; 5]) -> Vec<u8> { vec![arr[0] as u8, arr[1] as u8, arr[2] as u8, arr[3] as u8, arr[4] as u8] }
939}
940
941impl FromByteSlice for [char; 5] {
942    fn from_le_byte_slice(bytes: &[u8]) -> [char; 5] {
943        [bytes[0] as char, bytes[1] as char, bytes[2] as char, bytes[3] as char, bytes[4] as char]
944    }
945    fn bytes_expected() -> usize { 5 }
946}
947
948impl ToBytes for [i8; 32] {
949    fn to_le_byte_vec(arr: [i8; 32]) -> Vec<u8> {
950        vec![
951            arr[0] as u8,
952            arr[1] as u8,
953            arr[2] as u8,
954            arr[3] as u8,
955            arr[4] as u8,
956            arr[5] as u8,
957            arr[6] as u8,
958            arr[7] as u8,
959            arr[8] as u8,
960            arr[9] as u8,
961            arr[10] as u8,
962            arr[11] as u8,
963            arr[12] as u8,
964            arr[13] as u8,
965            arr[14] as u8,
966            arr[15] as u8,
967            arr[16] as u8,
968            arr[17] as u8,
969            arr[18] as u8,
970            arr[19] as u8,
971            arr[20] as u8,
972            arr[21] as u8,
973            arr[22] as u8,
974            arr[23] as u8,
975            arr[24] as u8,
976            arr[25] as u8,
977            arr[26] as u8,
978            arr[27] as u8,
979            arr[28] as u8,
980            arr[29] as u8,
981            arr[30] as u8,
982            arr[31] as u8,
983        ]
984    }
985}
986
987impl FromByteSlice for [i8; 32] {
988    fn from_le_byte_slice(bytes: &[u8]) -> [i8; 32] {
989        [
990            bytes[0] as i8,
991            bytes[1] as i8,
992            bytes[2] as i8,
993            bytes[3] as i8,
994            bytes[4] as i8,
995            bytes[5] as i8,
996            bytes[6] as i8,
997            bytes[7] as i8,
998            bytes[8] as i8,
999            bytes[9] as i8,
1000            bytes[10] as i8,
1001            bytes[11] as i8,
1002            bytes[12] as i8,
1003            bytes[13] as i8,
1004            bytes[14] as i8,
1005            bytes[15] as i8,
1006            bytes[16] as i8,
1007            bytes[17] as i8,
1008            bytes[18] as i8,
1009            bytes[19] as i8,
1010            bytes[20] as i8,
1011            bytes[21] as i8,
1012            bytes[22] as i8,
1013            bytes[23] as i8,
1014            bytes[24] as i8,
1015            bytes[25] as i8,
1016            bytes[26] as i8,
1017            bytes[27] as i8,
1018            bytes[28] as i8,
1019            bytes[29] as i8,
1020            bytes[30] as i8,
1021            bytes[31] as i8,
1022        ]
1023    }
1024    fn bytes_expected() -> usize { 32 }
1025}
1026
1027impl ToBytes for [char; 56] {
1028    fn to_le_byte_vec(arr: [char; 56]) -> Vec<u8> {
1029        vec![
1030            arr[0] as u8,
1031            arr[1] as u8,
1032            arr[2] as u8,
1033            arr[3] as u8,
1034            arr[4] as u8,
1035            arr[5] as u8,
1036            arr[6] as u8,
1037            arr[7] as u8,
1038            arr[8] as u8,
1039            arr[9] as u8,
1040            arr[10] as u8,
1041            arr[11] as u8,
1042            arr[12] as u8,
1043            arr[13] as u8,
1044            arr[14] as u8,
1045            arr[15] as u8,
1046            arr[16] as u8,
1047            arr[17] as u8,
1048            arr[18] as u8,
1049            arr[19] as u8,
1050            arr[20] as u8,
1051            arr[21] as u8,
1052            arr[22] as u8,
1053            arr[23] as u8,
1054            arr[24] as u8,
1055            arr[25] as u8,
1056            arr[26] as u8,
1057            arr[27] as u8,
1058            arr[28] as u8,
1059            arr[29] as u8,
1060            arr[30] as u8,
1061            arr[31] as u8,
1062            arr[32] as u8,
1063            arr[33] as u8,
1064            arr[34] as u8,
1065            arr[35] as u8,
1066            arr[36] as u8,
1067            arr[37] as u8,
1068            arr[38] as u8,
1069            arr[39] as u8,
1070            arr[40] as u8,
1071            arr[41] as u8,
1072            arr[42] as u8,
1073            arr[43] as u8,
1074            arr[44] as u8,
1075            arr[45] as u8,
1076            arr[46] as u8,
1077            arr[47] as u8,
1078            arr[48] as u8,
1079            arr[49] as u8,
1080            arr[50] as u8,
1081            arr[51] as u8,
1082            arr[52] as u8,
1083            arr[53] as u8,
1084            arr[54] as u8,
1085            arr[55] as u8,
1086        ]
1087    }
1088}
1089
1090impl FromByteSlice for [char; 56] {
1091    fn from_le_byte_slice(bytes: &[u8]) -> [char; 56] {
1092        [
1093            bytes[0] as char,
1094            bytes[1] as char,
1095            bytes[2] as char,
1096            bytes[3] as char,
1097            bytes[4] as char,
1098            bytes[5] as char,
1099            bytes[6] as char,
1100            bytes[7] as char,
1101            bytes[8] as char,
1102            bytes[9] as char,
1103            bytes[10] as char,
1104            bytes[11] as char,
1105            bytes[12] as char,
1106            bytes[13] as char,
1107            bytes[14] as char,
1108            bytes[15] as char,
1109            bytes[16] as char,
1110            bytes[17] as char,
1111            bytes[18] as char,
1112            bytes[19] as char,
1113            bytes[20] as char,
1114            bytes[21] as char,
1115            bytes[22] as char,
1116            bytes[23] as char,
1117            bytes[24] as char,
1118            bytes[25] as char,
1119            bytes[26] as char,
1120            bytes[27] as char,
1121            bytes[28] as char,
1122            bytes[29] as char,
1123            bytes[30] as char,
1124            bytes[31] as char,
1125            bytes[32] as char,
1126            bytes[33] as char,
1127            bytes[34] as char,
1128            bytes[35] as char,
1129            bytes[36] as char,
1130            bytes[37] as char,
1131            bytes[38] as char,
1132            bytes[39] as char,
1133            bytes[40] as char,
1134            bytes[41] as char,
1135            bytes[42] as char,
1136            bytes[43] as char,
1137            bytes[44] as char,
1138            bytes[45] as char,
1139            bytes[46] as char,
1140            bytes[47] as char,
1141            bytes[48] as char,
1142            bytes[49] as char,
1143            bytes[50] as char,
1144            bytes[51] as char,
1145            bytes[52] as char,
1146            bytes[53] as char,
1147            bytes[54] as char,
1148            bytes[55] as char,
1149        ]
1150    }
1151    fn bytes_expected() -> usize { 56 }
1152}
1153
1154impl ToBytes for [char; 58] {
1155    fn to_le_byte_vec(arr: [char; 58]) -> Vec<u8> {
1156        vec![
1157            arr[0] as u8,
1158            arr[1] as u8,
1159            arr[2] as u8,
1160            arr[3] as u8,
1161            arr[4] as u8,
1162            arr[5] as u8,
1163            arr[6] as u8,
1164            arr[7] as u8,
1165            arr[8] as u8,
1166            arr[9] as u8,
1167            arr[10] as u8,
1168            arr[11] as u8,
1169            arr[12] as u8,
1170            arr[13] as u8,
1171            arr[14] as u8,
1172            arr[15] as u8,
1173            arr[16] as u8,
1174            arr[17] as u8,
1175            arr[18] as u8,
1176            arr[19] as u8,
1177            arr[20] as u8,
1178            arr[21] as u8,
1179            arr[22] as u8,
1180            arr[23] as u8,
1181            arr[24] as u8,
1182            arr[25] as u8,
1183            arr[26] as u8,
1184            arr[27] as u8,
1185            arr[28] as u8,
1186            arr[29] as u8,
1187            arr[30] as u8,
1188            arr[31] as u8,
1189            arr[32] as u8,
1190            arr[33] as u8,
1191            arr[34] as u8,
1192            arr[35] as u8,
1193            arr[36] as u8,
1194            arr[37] as u8,
1195            arr[38] as u8,
1196            arr[39] as u8,
1197            arr[40] as u8,
1198            arr[41] as u8,
1199            arr[42] as u8,
1200            arr[43] as u8,
1201            arr[44] as u8,
1202            arr[45] as u8,
1203            arr[46] as u8,
1204            arr[47] as u8,
1205            arr[48] as u8,
1206            arr[49] as u8,
1207            arr[50] as u8,
1208            arr[51] as u8,
1209            arr[52] as u8,
1210            arr[53] as u8,
1211            arr[54] as u8,
1212            arr[55] as u8,
1213            arr[56] as u8,
1214            arr[57] as u8,
1215        ]
1216    }
1217}
1218
1219impl FromByteSlice for [char; 58] {
1220    fn from_le_byte_slice(bytes: &[u8]) -> [char; 58] {
1221        [
1222            bytes[0] as char,
1223            bytes[1] as char,
1224            bytes[2] as char,
1225            bytes[3] as char,
1226            bytes[4] as char,
1227            bytes[5] as char,
1228            bytes[6] as char,
1229            bytes[7] as char,
1230            bytes[8] as char,
1231            bytes[9] as char,
1232            bytes[10] as char,
1233            bytes[11] as char,
1234            bytes[12] as char,
1235            bytes[13] as char,
1236            bytes[14] as char,
1237            bytes[15] as char,
1238            bytes[16] as char,
1239            bytes[17] as char,
1240            bytes[18] as char,
1241            bytes[19] as char,
1242            bytes[20] as char,
1243            bytes[21] as char,
1244            bytes[22] as char,
1245            bytes[23] as char,
1246            bytes[24] as char,
1247            bytes[25] as char,
1248            bytes[26] as char,
1249            bytes[27] as char,
1250            bytes[28] as char,
1251            bytes[29] as char,
1252            bytes[30] as char,
1253            bytes[31] as char,
1254            bytes[32] as char,
1255            bytes[33] as char,
1256            bytes[34] as char,
1257            bytes[35] as char,
1258            bytes[36] as char,
1259            bytes[37] as char,
1260            bytes[38] as char,
1261            bytes[39] as char,
1262            bytes[40] as char,
1263            bytes[41] as char,
1264            bytes[42] as char,
1265            bytes[43] as char,
1266            bytes[44] as char,
1267            bytes[45] as char,
1268            bytes[46] as char,
1269            bytes[47] as char,
1270            bytes[48] as char,
1271            bytes[49] as char,
1272            bytes[50] as char,
1273            bytes[51] as char,
1274            bytes[52] as char,
1275            bytes[53] as char,
1276            bytes[54] as char,
1277            bytes[55] as char,
1278            bytes[56] as char,
1279            bytes[57] as char,
1280        ]
1281    }
1282    fn bytes_expected() -> usize { 58 }
1283}
1284
1285impl ToBytes for [char; 59] {
1286    fn to_le_byte_vec(arr: [char; 59]) -> Vec<u8> {
1287        vec![
1288            arr[0] as u8,
1289            arr[1] as u8,
1290            arr[2] as u8,
1291            arr[3] as u8,
1292            arr[4] as u8,
1293            arr[5] as u8,
1294            arr[6] as u8,
1295            arr[7] as u8,
1296            arr[8] as u8,
1297            arr[9] as u8,
1298            arr[10] as u8,
1299            arr[11] as u8,
1300            arr[12] as u8,
1301            arr[13] as u8,
1302            arr[14] as u8,
1303            arr[15] as u8,
1304            arr[16] as u8,
1305            arr[17] as u8,
1306            arr[18] as u8,
1307            arr[19] as u8,
1308            arr[20] as u8,
1309            arr[21] as u8,
1310            arr[22] as u8,
1311            arr[23] as u8,
1312            arr[24] as u8,
1313            arr[25] as u8,
1314            arr[26] as u8,
1315            arr[27] as u8,
1316            arr[28] as u8,
1317            arr[29] as u8,
1318            arr[30] as u8,
1319            arr[31] as u8,
1320            arr[32] as u8,
1321            arr[33] as u8,
1322            arr[34] as u8,
1323            arr[35] as u8,
1324            arr[36] as u8,
1325            arr[37] as u8,
1326            arr[38] as u8,
1327            arr[39] as u8,
1328            arr[40] as u8,
1329            arr[41] as u8,
1330            arr[42] as u8,
1331            arr[43] as u8,
1332            arr[44] as u8,
1333            arr[45] as u8,
1334            arr[46] as u8,
1335            arr[47] as u8,
1336            arr[48] as u8,
1337            arr[49] as u8,
1338            arr[50] as u8,
1339            arr[51] as u8,
1340            arr[52] as u8,
1341            arr[53] as u8,
1342            arr[54] as u8,
1343            arr[55] as u8,
1344            arr[56] as u8,
1345            arr[57] as u8,
1346            arr[58] as u8,
1347        ]
1348    }
1349}
1350
1351impl FromByteSlice for [char; 59] {
1352    fn from_le_byte_slice(bytes: &[u8]) -> [char; 59] {
1353        [
1354            bytes[0] as char,
1355            bytes[1] as char,
1356            bytes[2] as char,
1357            bytes[3] as char,
1358            bytes[4] as char,
1359            bytes[5] as char,
1360            bytes[6] as char,
1361            bytes[7] as char,
1362            bytes[8] as char,
1363            bytes[9] as char,
1364            bytes[10] as char,
1365            bytes[11] as char,
1366            bytes[12] as char,
1367            bytes[13] as char,
1368            bytes[14] as char,
1369            bytes[15] as char,
1370            bytes[16] as char,
1371            bytes[17] as char,
1372            bytes[18] as char,
1373            bytes[19] as char,
1374            bytes[20] as char,
1375            bytes[21] as char,
1376            bytes[22] as char,
1377            bytes[23] as char,
1378            bytes[24] as char,
1379            bytes[25] as char,
1380            bytes[26] as char,
1381            bytes[27] as char,
1382            bytes[28] as char,
1383            bytes[29] as char,
1384            bytes[30] as char,
1385            bytes[31] as char,
1386            bytes[32] as char,
1387            bytes[33] as char,
1388            bytes[34] as char,
1389            bytes[35] as char,
1390            bytes[36] as char,
1391            bytes[37] as char,
1392            bytes[38] as char,
1393            bytes[39] as char,
1394            bytes[40] as char,
1395            bytes[41] as char,
1396            bytes[42] as char,
1397            bytes[43] as char,
1398            bytes[44] as char,
1399            bytes[45] as char,
1400            bytes[46] as char,
1401            bytes[47] as char,
1402            bytes[48] as char,
1403            bytes[49] as char,
1404            bytes[50] as char,
1405            bytes[51] as char,
1406            bytes[52] as char,
1407            bytes[53] as char,
1408            bytes[54] as char,
1409            bytes[55] as char,
1410            bytes[56] as char,
1411            bytes[57] as char,
1412            bytes[58] as char,
1413        ]
1414    }
1415    fn bytes_expected() -> usize { 59 }
1416}
1417
1418impl ToBytes for [i8; 60] {
1419    fn to_le_byte_vec(arr: [i8; 60]) -> Vec<u8> {
1420        vec![
1421            arr[0] as u8,
1422            arr[1] as u8,
1423            arr[2] as u8,
1424            arr[3] as u8,
1425            arr[4] as u8,
1426            arr[5] as u8,
1427            arr[6] as u8,
1428            arr[7] as u8,
1429            arr[8] as u8,
1430            arr[9] as u8,
1431            arr[10] as u8,
1432            arr[11] as u8,
1433            arr[12] as u8,
1434            arr[13] as u8,
1435            arr[14] as u8,
1436            arr[15] as u8,
1437            arr[16] as u8,
1438            arr[17] as u8,
1439            arr[18] as u8,
1440            arr[19] as u8,
1441            arr[20] as u8,
1442            arr[21] as u8,
1443            arr[22] as u8,
1444            arr[23] as u8,
1445            arr[24] as u8,
1446            arr[25] as u8,
1447            arr[26] as u8,
1448            arr[27] as u8,
1449            arr[28] as u8,
1450            arr[29] as u8,
1451            arr[30] as u8,
1452            arr[31] as u8,
1453            arr[32] as u8,
1454            arr[33] as u8,
1455            arr[34] as u8,
1456            arr[35] as u8,
1457            arr[36] as u8,
1458            arr[37] as u8,
1459            arr[38] as u8,
1460            arr[39] as u8,
1461            arr[40] as u8,
1462            arr[41] as u8,
1463            arr[42] as u8,
1464            arr[43] as u8,
1465            arr[44] as u8,
1466            arr[45] as u8,
1467            arr[46] as u8,
1468            arr[47] as u8,
1469            arr[48] as u8,
1470            arr[49] as u8,
1471            arr[50] as u8,
1472            arr[51] as u8,
1473            arr[52] as u8,
1474            arr[53] as u8,
1475            arr[54] as u8,
1476            arr[55] as u8,
1477            arr[56] as u8,
1478            arr[57] as u8,
1479            arr[58] as u8,
1480            arr[59] as u8,
1481        ]
1482    }
1483}
1484
1485impl FromByteSlice for [i8; 60] {
1486    fn from_le_byte_slice(bytes: &[u8]) -> [i8; 60] {
1487        [
1488            bytes[0] as i8,
1489            bytes[1] as i8,
1490            bytes[2] as i8,
1491            bytes[3] as i8,
1492            bytes[4] as i8,
1493            bytes[5] as i8,
1494            bytes[6] as i8,
1495            bytes[7] as i8,
1496            bytes[8] as i8,
1497            bytes[9] as i8,
1498            bytes[10] as i8,
1499            bytes[11] as i8,
1500            bytes[12] as i8,
1501            bytes[13] as i8,
1502            bytes[14] as i8,
1503            bytes[15] as i8,
1504            bytes[16] as i8,
1505            bytes[17] as i8,
1506            bytes[18] as i8,
1507            bytes[19] as i8,
1508            bytes[20] as i8,
1509            bytes[21] as i8,
1510            bytes[22] as i8,
1511            bytes[23] as i8,
1512            bytes[24] as i8,
1513            bytes[25] as i8,
1514            bytes[26] as i8,
1515            bytes[27] as i8,
1516            bytes[28] as i8,
1517            bytes[29] as i8,
1518            bytes[30] as i8,
1519            bytes[31] as i8,
1520            bytes[32] as i8,
1521            bytes[33] as i8,
1522            bytes[34] as i8,
1523            bytes[35] as i8,
1524            bytes[36] as i8,
1525            bytes[37] as i8,
1526            bytes[38] as i8,
1527            bytes[39] as i8,
1528            bytes[40] as i8,
1529            bytes[41] as i8,
1530            bytes[42] as i8,
1531            bytes[43] as i8,
1532            bytes[44] as i8,
1533            bytes[45] as i8,
1534            bytes[46] as i8,
1535            bytes[47] as i8,
1536            bytes[48] as i8,
1537            bytes[49] as i8,
1538            bytes[50] as i8,
1539            bytes[51] as i8,
1540            bytes[52] as i8,
1541            bytes[53] as i8,
1542            bytes[54] as i8,
1543            bytes[55] as i8,
1544            bytes[56] as i8,
1545            bytes[57] as i8,
1546            bytes[58] as i8,
1547            bytes[59] as i8,
1548        ]
1549    }
1550    fn bytes_expected() -> usize { 60 }
1551}
1552
1553impl ToBytes for [char; 60] {
1554    fn to_le_byte_vec(arr: [char; 60]) -> Vec<u8> {
1555        vec![
1556            arr[0] as u8,
1557            arr[1] as u8,
1558            arr[2] as u8,
1559            arr[3] as u8,
1560            arr[4] as u8,
1561            arr[5] as u8,
1562            arr[6] as u8,
1563            arr[7] as u8,
1564            arr[8] as u8,
1565            arr[9] as u8,
1566            arr[10] as u8,
1567            arr[11] as u8,
1568            arr[12] as u8,
1569            arr[13] as u8,
1570            arr[14] as u8,
1571            arr[15] as u8,
1572            arr[16] as u8,
1573            arr[17] as u8,
1574            arr[18] as u8,
1575            arr[19] as u8,
1576            arr[20] as u8,
1577            arr[21] as u8,
1578            arr[22] as u8,
1579            arr[23] as u8,
1580            arr[24] as u8,
1581            arr[25] as u8,
1582            arr[26] as u8,
1583            arr[27] as u8,
1584            arr[28] as u8,
1585            arr[29] as u8,
1586            arr[30] as u8,
1587            arr[31] as u8,
1588            arr[32] as u8,
1589            arr[33] as u8,
1590            arr[34] as u8,
1591            arr[35] as u8,
1592            arr[36] as u8,
1593            arr[37] as u8,
1594            arr[38] as u8,
1595            arr[39] as u8,
1596            arr[40] as u8,
1597            arr[41] as u8,
1598            arr[42] as u8,
1599            arr[43] as u8,
1600            arr[44] as u8,
1601            arr[45] as u8,
1602            arr[46] as u8,
1603            arr[47] as u8,
1604            arr[48] as u8,
1605            arr[49] as u8,
1606            arr[50] as u8,
1607            arr[51] as u8,
1608            arr[52] as u8,
1609            arr[53] as u8,
1610            arr[54] as u8,
1611            arr[55] as u8,
1612            arr[56] as u8,
1613            arr[57] as u8,
1614            arr[58] as u8,
1615            arr[59] as u8,
1616        ]
1617    }
1618}
1619
1620impl FromByteSlice for [char; 60] {
1621    fn from_le_byte_slice(bytes: &[u8]) -> [char; 60] {
1622        [
1623            bytes[0] as char,
1624            bytes[1] as char,
1625            bytes[2] as char,
1626            bytes[3] as char,
1627            bytes[4] as char,
1628            bytes[5] as char,
1629            bytes[6] as char,
1630            bytes[7] as char,
1631            bytes[8] as char,
1632            bytes[9] as char,
1633            bytes[10] as char,
1634            bytes[11] as char,
1635            bytes[12] as char,
1636            bytes[13] as char,
1637            bytes[14] as char,
1638            bytes[15] as char,
1639            bytes[16] as char,
1640            bytes[17] as char,
1641            bytes[18] as char,
1642            bytes[19] as char,
1643            bytes[20] as char,
1644            bytes[21] as char,
1645            bytes[22] as char,
1646            bytes[23] as char,
1647            bytes[24] as char,
1648            bytes[25] as char,
1649            bytes[26] as char,
1650            bytes[27] as char,
1651            bytes[28] as char,
1652            bytes[29] as char,
1653            bytes[30] as char,
1654            bytes[31] as char,
1655            bytes[32] as char,
1656            bytes[33] as char,
1657            bytes[34] as char,
1658            bytes[35] as char,
1659            bytes[36] as char,
1660            bytes[37] as char,
1661            bytes[38] as char,
1662            bytes[39] as char,
1663            bytes[40] as char,
1664            bytes[41] as char,
1665            bytes[42] as char,
1666            bytes[43] as char,
1667            bytes[44] as char,
1668            bytes[45] as char,
1669            bytes[46] as char,
1670            bytes[47] as char,
1671            bytes[48] as char,
1672            bytes[49] as char,
1673            bytes[50] as char,
1674            bytes[51] as char,
1675            bytes[52] as char,
1676            bytes[53] as char,
1677            bytes[54] as char,
1678            bytes[55] as char,
1679            bytes[56] as char,
1680            bytes[57] as char,
1681            bytes[58] as char,
1682            bytes[59] as char,
1683        ]
1684    }
1685    fn bytes_expected() -> usize { 60 }
1686}
1687
1688impl ToBytes for [char; 61] {
1689    fn to_le_byte_vec(arr: [char; 61]) -> Vec<u8> {
1690        vec![
1691            arr[0] as u8,
1692            arr[1] as u8,
1693            arr[2] as u8,
1694            arr[3] as u8,
1695            arr[4] as u8,
1696            arr[5] as u8,
1697            arr[6] as u8,
1698            arr[7] as u8,
1699            arr[8] as u8,
1700            arr[9] as u8,
1701            arr[10] as u8,
1702            arr[11] as u8,
1703            arr[12] as u8,
1704            arr[13] as u8,
1705            arr[14] as u8,
1706            arr[15] as u8,
1707            arr[16] as u8,
1708            arr[17] as u8,
1709            arr[18] as u8,
1710            arr[19] as u8,
1711            arr[20] as u8,
1712            arr[21] as u8,
1713            arr[22] as u8,
1714            arr[23] as u8,
1715            arr[24] as u8,
1716            arr[25] as u8,
1717            arr[26] as u8,
1718            arr[27] as u8,
1719            arr[28] as u8,
1720            arr[29] as u8,
1721            arr[30] as u8,
1722            arr[31] as u8,
1723            arr[32] as u8,
1724            arr[33] as u8,
1725            arr[34] as u8,
1726            arr[35] as u8,
1727            arr[36] as u8,
1728            arr[37] as u8,
1729            arr[38] as u8,
1730            arr[39] as u8,
1731            arr[40] as u8,
1732            arr[41] as u8,
1733            arr[42] as u8,
1734            arr[43] as u8,
1735            arr[44] as u8,
1736            arr[45] as u8,
1737            arr[46] as u8,
1738            arr[47] as u8,
1739            arr[48] as u8,
1740            arr[49] as u8,
1741            arr[50] as u8,
1742            arr[51] as u8,
1743            arr[52] as u8,
1744            arr[53] as u8,
1745            arr[54] as u8,
1746            arr[55] as u8,
1747            arr[56] as u8,
1748            arr[57] as u8,
1749            arr[58] as u8,
1750            arr[59] as u8,
1751            arr[60] as u8,
1752        ]
1753    }
1754}
1755
1756impl FromByteSlice for [char; 61] {
1757    fn from_le_byte_slice(bytes: &[u8]) -> [char; 61] {
1758        [
1759            bytes[0] as char,
1760            bytes[1] as char,
1761            bytes[2] as char,
1762            bytes[3] as char,
1763            bytes[4] as char,
1764            bytes[5] as char,
1765            bytes[6] as char,
1766            bytes[7] as char,
1767            bytes[8] as char,
1768            bytes[9] as char,
1769            bytes[10] as char,
1770            bytes[11] as char,
1771            bytes[12] as char,
1772            bytes[13] as char,
1773            bytes[14] as char,
1774            bytes[15] as char,
1775            bytes[16] as char,
1776            bytes[17] as char,
1777            bytes[18] as char,
1778            bytes[19] as char,
1779            bytes[20] as char,
1780            bytes[21] as char,
1781            bytes[22] as char,
1782            bytes[23] as char,
1783            bytes[24] as char,
1784            bytes[25] as char,
1785            bytes[26] as char,
1786            bytes[27] as char,
1787            bytes[28] as char,
1788            bytes[29] as char,
1789            bytes[30] as char,
1790            bytes[31] as char,
1791            bytes[32] as char,
1792            bytes[33] as char,
1793            bytes[34] as char,
1794            bytes[35] as char,
1795            bytes[36] as char,
1796            bytes[37] as char,
1797            bytes[38] as char,
1798            bytes[39] as char,
1799            bytes[40] as char,
1800            bytes[41] as char,
1801            bytes[42] as char,
1802            bytes[43] as char,
1803            bytes[44] as char,
1804            bytes[45] as char,
1805            bytes[46] as char,
1806            bytes[47] as char,
1807            bytes[48] as char,
1808            bytes[49] as char,
1809            bytes[50] as char,
1810            bytes[51] as char,
1811            bytes[52] as char,
1812            bytes[53] as char,
1813            bytes[54] as char,
1814            bytes[55] as char,
1815            bytes[56] as char,
1816            bytes[57] as char,
1817            bytes[58] as char,
1818            bytes[59] as char,
1819            bytes[60] as char,
1820        ]
1821    }
1822    fn bytes_expected() -> usize { 61 }
1823}
1824
1825impl ToBytes for [char; 62] {
1826    fn to_le_byte_vec(arr: [char; 62]) -> Vec<u8> {
1827        vec![
1828            arr[0] as u8,
1829            arr[1] as u8,
1830            arr[2] as u8,
1831            arr[3] as u8,
1832            arr[4] as u8,
1833            arr[5] as u8,
1834            arr[6] as u8,
1835            arr[7] as u8,
1836            arr[8] as u8,
1837            arr[9] as u8,
1838            arr[10] as u8,
1839            arr[11] as u8,
1840            arr[12] as u8,
1841            arr[13] as u8,
1842            arr[14] as u8,
1843            arr[15] as u8,
1844            arr[16] as u8,
1845            arr[17] as u8,
1846            arr[18] as u8,
1847            arr[19] as u8,
1848            arr[20] as u8,
1849            arr[21] as u8,
1850            arr[22] as u8,
1851            arr[23] as u8,
1852            arr[24] as u8,
1853            arr[25] as u8,
1854            arr[26] as u8,
1855            arr[27] as u8,
1856            arr[28] as u8,
1857            arr[29] as u8,
1858            arr[30] as u8,
1859            arr[31] as u8,
1860            arr[32] as u8,
1861            arr[33] as u8,
1862            arr[34] as u8,
1863            arr[35] as u8,
1864            arr[36] as u8,
1865            arr[37] as u8,
1866            arr[38] as u8,
1867            arr[39] as u8,
1868            arr[40] as u8,
1869            arr[41] as u8,
1870            arr[42] as u8,
1871            arr[43] as u8,
1872            arr[44] as u8,
1873            arr[45] as u8,
1874            arr[46] as u8,
1875            arr[47] as u8,
1876            arr[48] as u8,
1877            arr[49] as u8,
1878            arr[50] as u8,
1879            arr[51] as u8,
1880            arr[52] as u8,
1881            arr[53] as u8,
1882            arr[54] as u8,
1883            arr[55] as u8,
1884            arr[56] as u8,
1885            arr[57] as u8,
1886            arr[58] as u8,
1887            arr[59] as u8,
1888            arr[60] as u8,
1889            arr[61] as u8,
1890        ]
1891    }
1892}
1893
1894impl FromByteSlice for [char; 62] {
1895    fn from_le_byte_slice(bytes: &[u8]) -> [char; 62] {
1896        [
1897            bytes[0] as char,
1898            bytes[1] as char,
1899            bytes[2] as char,
1900            bytes[3] as char,
1901            bytes[4] as char,
1902            bytes[5] as char,
1903            bytes[6] as char,
1904            bytes[7] as char,
1905            bytes[8] as char,
1906            bytes[9] as char,
1907            bytes[10] as char,
1908            bytes[11] as char,
1909            bytes[12] as char,
1910            bytes[13] as char,
1911            bytes[14] as char,
1912            bytes[15] as char,
1913            bytes[16] as char,
1914            bytes[17] as char,
1915            bytes[18] as char,
1916            bytes[19] as char,
1917            bytes[20] as char,
1918            bytes[21] as char,
1919            bytes[22] as char,
1920            bytes[23] as char,
1921            bytes[24] as char,
1922            bytes[25] as char,
1923            bytes[26] as char,
1924            bytes[27] as char,
1925            bytes[28] as char,
1926            bytes[29] as char,
1927            bytes[30] as char,
1928            bytes[31] as char,
1929            bytes[32] as char,
1930            bytes[33] as char,
1931            bytes[34] as char,
1932            bytes[35] as char,
1933            bytes[36] as char,
1934            bytes[37] as char,
1935            bytes[38] as char,
1936            bytes[39] as char,
1937            bytes[40] as char,
1938            bytes[41] as char,
1939            bytes[42] as char,
1940            bytes[43] as char,
1941            bytes[44] as char,
1942            bytes[45] as char,
1943            bytes[46] as char,
1944            bytes[47] as char,
1945            bytes[48] as char,
1946            bytes[49] as char,
1947            bytes[50] as char,
1948            bytes[51] as char,
1949            bytes[52] as char,
1950            bytes[53] as char,
1951            bytes[54] as char,
1952            bytes[55] as char,
1953            bytes[56] as char,
1954            bytes[57] as char,
1955            bytes[58] as char,
1956            bytes[59] as char,
1957            bytes[60] as char,
1958            bytes[61] as char,
1959        ]
1960    }
1961    fn bytes_expected() -> usize { 62 }
1962}
1963
1964impl ToBytes for [char; 63] {
1965    fn to_le_byte_vec(arr: [char; 63]) -> Vec<u8> {
1966        vec![
1967            arr[0] as u8,
1968            arr[1] as u8,
1969            arr[2] as u8,
1970            arr[3] as u8,
1971            arr[4] as u8,
1972            arr[5] as u8,
1973            arr[6] as u8,
1974            arr[7] as u8,
1975            arr[8] as u8,
1976            arr[9] as u8,
1977            arr[10] as u8,
1978            arr[11] as u8,
1979            arr[12] as u8,
1980            arr[13] as u8,
1981            arr[14] as u8,
1982            arr[15] as u8,
1983            arr[16] as u8,
1984            arr[17] as u8,
1985            arr[18] as u8,
1986            arr[19] as u8,
1987            arr[20] as u8,
1988            arr[21] as u8,
1989            arr[22] as u8,
1990            arr[23] as u8,
1991            arr[24] as u8,
1992            arr[25] as u8,
1993            arr[26] as u8,
1994            arr[27] as u8,
1995            arr[28] as u8,
1996            arr[29] as u8,
1997            arr[30] as u8,
1998            arr[31] as u8,
1999            arr[32] as u8,
2000            arr[33] as u8,
2001            arr[34] as u8,
2002            arr[35] as u8,
2003            arr[36] as u8,
2004            arr[37] as u8,
2005            arr[38] as u8,
2006            arr[39] as u8,
2007            arr[40] as u8,
2008            arr[41] as u8,
2009            arr[42] as u8,
2010            arr[43] as u8,
2011            arr[44] as u8,
2012            arr[45] as u8,
2013            arr[46] as u8,
2014            arr[47] as u8,
2015            arr[48] as u8,
2016            arr[49] as u8,
2017            arr[50] as u8,
2018            arr[51] as u8,
2019            arr[52] as u8,
2020            arr[53] as u8,
2021            arr[54] as u8,
2022            arr[55] as u8,
2023            arr[56] as u8,
2024            arr[57] as u8,
2025            arr[58] as u8,
2026            arr[59] as u8,
2027            arr[60] as u8,
2028            arr[61] as u8,
2029            arr[62] as u8,
2030        ]
2031    }
2032}
2033
2034impl FromByteSlice for [char; 63] {
2035    fn from_le_byte_slice(bytes: &[u8]) -> [char; 63] {
2036        [
2037            bytes[0] as char,
2038            bytes[1] as char,
2039            bytes[2] as char,
2040            bytes[3] as char,
2041            bytes[4] as char,
2042            bytes[5] as char,
2043            bytes[6] as char,
2044            bytes[7] as char,
2045            bytes[8] as char,
2046            bytes[9] as char,
2047            bytes[10] as char,
2048            bytes[11] as char,
2049            bytes[12] as char,
2050            bytes[13] as char,
2051            bytes[14] as char,
2052            bytes[15] as char,
2053            bytes[16] as char,
2054            bytes[17] as char,
2055            bytes[18] as char,
2056            bytes[19] as char,
2057            bytes[20] as char,
2058            bytes[21] as char,
2059            bytes[22] as char,
2060            bytes[23] as char,
2061            bytes[24] as char,
2062            bytes[25] as char,
2063            bytes[26] as char,
2064            bytes[27] as char,
2065            bytes[28] as char,
2066            bytes[29] as char,
2067            bytes[30] as char,
2068            bytes[31] as char,
2069            bytes[32] as char,
2070            bytes[33] as char,
2071            bytes[34] as char,
2072            bytes[35] as char,
2073            bytes[36] as char,
2074            bytes[37] as char,
2075            bytes[38] as char,
2076            bytes[39] as char,
2077            bytes[40] as char,
2078            bytes[41] as char,
2079            bytes[42] as char,
2080            bytes[43] as char,
2081            bytes[44] as char,
2082            bytes[45] as char,
2083            bytes[46] as char,
2084            bytes[47] as char,
2085            bytes[48] as char,
2086            bytes[49] as char,
2087            bytes[50] as char,
2088            bytes[51] as char,
2089            bytes[52] as char,
2090            bytes[53] as char,
2091            bytes[54] as char,
2092            bytes[55] as char,
2093            bytes[56] as char,
2094            bytes[57] as char,
2095            bytes[58] as char,
2096            bytes[59] as char,
2097            bytes[60] as char,
2098            bytes[61] as char,
2099            bytes[62] as char,
2100        ]
2101    }
2102    fn bytes_expected() -> usize { 63 }
2103}
2104
2105impl ToBytes for [u16; 2] {
2106    fn to_le_byte_vec(arr: [u16; 2]) -> Vec<u8> {
2107        let mut buf = vec![0, 4];
2108        LittleEndian::write_u16_into(&arr, &mut buf);
2109        buf
2110    }
2111}
2112
2113impl FromByteSlice for [u16; 2] {
2114    fn from_le_byte_slice(bytes: &[u8]) -> [u16; 2] {
2115        let mut buf = [0u16; 2];
2116        LittleEndian::read_u16_into(&bytes, &mut buf);
2117        buf
2118    }
2119    fn bytes_expected() -> usize { 4 }
2120}
2121
2122impl ToBytes for [u16; 4] {
2123    fn to_le_byte_vec(arr: [u16; 4]) -> Vec<u8> {
2124        let mut buf = vec![0, 8];
2125        LittleEndian::write_u16_into(&arr, &mut buf);
2126        buf
2127    }
2128}
2129
2130impl FromByteSlice for [u16; 4] {
2131    fn from_le_byte_slice(bytes: &[u8]) -> [u16; 4] {
2132        let mut buf = [0u16; 4];
2133        LittleEndian::read_u16_into(&bytes, &mut buf);
2134        buf
2135    }
2136    fn bytes_expected() -> usize { 8 }
2137}
2138
2139impl ToBytes for [u16; 7] {
2140    fn to_le_byte_vec(arr: [u16; 7]) -> Vec<u8> {
2141        let mut buf = vec![0, 14];
2142        LittleEndian::write_u16_into(&arr, &mut buf);
2143        buf
2144    }
2145}
2146
2147impl FromByteSlice for [u16; 7] {
2148    fn from_le_byte_slice(bytes: &[u8]) -> [u16; 7] {
2149        let mut buf = [0u16; 7];
2150        LittleEndian::read_u16_into(&bytes, &mut buf);
2151        buf
2152    }
2153    fn bytes_expected() -> usize { 14 }
2154}
2155
2156impl ToBytes for [u16; 8] {
2157    fn to_le_byte_vec(arr: [u16; 8]) -> Vec<u8> {
2158        let mut buf = vec![0, 16];
2159        LittleEndian::write_u16_into(&arr, &mut buf);
2160        buf
2161    }
2162}
2163
2164impl FromByteSlice for [u16; 8] {
2165    fn from_le_byte_slice(bytes: &[u8]) -> [u16; 8] {
2166        let mut buf = [0u16; 8];
2167        LittleEndian::read_u16_into(&bytes, &mut buf);
2168        buf
2169    }
2170    fn bytes_expected() -> usize { 16 }
2171}
2172
2173impl ToBytes for [u16; 10] {
2174    fn to_le_byte_vec(arr: [u16; 10]) -> Vec<u8> {
2175        let mut buf = vec![0, 20];
2176        LittleEndian::write_u16_into(&arr, &mut buf);
2177        buf
2178    }
2179}
2180
2181impl FromByteSlice for [u16; 10] {
2182    fn from_le_byte_slice(bytes: &[u8]) -> [u16; 10] {
2183        let mut buf = [0u16; 10];
2184        LittleEndian::read_u16_into(&bytes, &mut buf);
2185        buf
2186    }
2187    fn bytes_expected() -> usize { 20 }
2188}
2189
2190impl ToBytes for [u16; 20] {
2191    fn to_le_byte_vec(arr: [u16; 20]) -> Vec<u8> {
2192        let mut buf = vec![0, 40];
2193        LittleEndian::write_u16_into(&arr, &mut buf);
2194        buf
2195    }
2196}
2197
2198impl FromByteSlice for [u16; 20] {
2199    fn from_le_byte_slice(bytes: &[u8]) -> [u16; 20] {
2200        let mut buf = [0u16; 20];
2201        LittleEndian::read_u16_into(&bytes, &mut buf);
2202        buf
2203    }
2204    fn bytes_expected() -> usize { 40 }
2205}
2206
2207impl ToBytes for [u16; 27] {
2208    fn to_le_byte_vec(arr: [u16; 27]) -> Vec<u8> {
2209        let mut buf = vec![0, 54];
2210        LittleEndian::write_u16_into(&arr, &mut buf);
2211        buf
2212    }
2213}
2214
2215impl FromByteSlice for [u16; 27] {
2216    fn from_le_byte_slice(bytes: &[u8]) -> [u16; 27] {
2217        let mut buf = [0u16; 27];
2218        LittleEndian::read_u16_into(&bytes, &mut buf);
2219        buf
2220    }
2221    fn bytes_expected() -> usize { 54 }
2222}
2223
2224impl ToBytes for [u16; 29] {
2225    fn to_le_byte_vec(arr: [u16; 29]) -> Vec<u8> {
2226        let mut buf = vec![0, 58];
2227        LittleEndian::write_u16_into(&arr, &mut buf);
2228        buf
2229    }
2230}
2231
2232impl FromByteSlice for [u16; 29] {
2233    fn from_le_byte_slice(bytes: &[u8]) -> [u16; 29] {
2234        let mut buf = [0u16; 29];
2235        LittleEndian::read_u16_into(&bytes, &mut buf);
2236        buf
2237    }
2238    fn bytes_expected() -> usize { 58 }
2239}
2240
2241impl ToBytes for [u16; 30] {
2242    fn to_le_byte_vec(arr: [u16; 30]) -> Vec<u8> {
2243        let mut buf = vec![0, 60];
2244        LittleEndian::write_u16_into(&arr, &mut buf);
2245        buf
2246    }
2247}
2248
2249impl FromByteSlice for [u16; 30] {
2250    fn from_le_byte_slice(bytes: &[u8]) -> [u16; 30] {
2251        let mut buf = [0u16; 30];
2252        LittleEndian::read_u16_into(&bytes, &mut buf);
2253        buf
2254    }
2255    fn bytes_expected() -> usize { 60 }
2256}
2257
2258impl ToBytes for [u16; 31] {
2259    fn to_le_byte_vec(arr: [u16; 31]) -> Vec<u8> {
2260        let mut buf = vec![0, 62];
2261        LittleEndian::write_u16_into(&arr, &mut buf);
2262        buf
2263    }
2264}
2265
2266impl FromByteSlice for [u16; 31] {
2267    fn from_le_byte_slice(bytes: &[u8]) -> [u16; 31] {
2268        let mut buf = [0u16; 31];
2269        LittleEndian::read_u16_into(&bytes, &mut buf);
2270        buf
2271    }
2272    fn bytes_expected() -> usize { 62 }
2273}
2274
2275impl ToBytes for [i16; 3] {
2276    fn to_le_byte_vec(arr: [i16; 3]) -> Vec<u8> {
2277        let mut buf = vec![0, 6];
2278        LittleEndian::write_i16_into(&arr, &mut buf);
2279        buf
2280    }
2281}
2282
2283impl FromByteSlice for [i16; 3] {
2284    fn from_le_byte_slice(bytes: &[u8]) -> [i16; 3] {
2285        let mut buf = [0i16; 3];
2286        LittleEndian::read_i16_into(&bytes, &mut buf);
2287        buf
2288    }
2289    fn bytes_expected() -> usize { 6 }
2290}
2291
2292impl ToBytes for [i16; 4] {
2293    fn to_le_byte_vec(arr: [i16; 4]) -> Vec<u8> {
2294        let mut buf = vec![0, 8];
2295        LittleEndian::write_i16_into(&arr, &mut buf);
2296        buf
2297    }
2298}
2299
2300impl FromByteSlice for [i16; 4] {
2301    fn from_le_byte_slice(bytes: &[u8]) -> [i16; 4] {
2302        let mut buf = [0i16; 4];
2303        LittleEndian::read_i16_into(&bytes, &mut buf);
2304        buf
2305    }
2306    fn bytes_expected() -> usize { 8 }
2307}
2308
2309impl ToBytes for [i16; 7] {
2310    fn to_le_byte_vec(arr: [i16; 7]) -> Vec<u8> {
2311        let mut buf = vec![0, 14];
2312        LittleEndian::write_i16_into(&arr, &mut buf);
2313        buf
2314    }
2315}
2316
2317impl FromByteSlice for [i16; 7] {
2318    fn from_le_byte_slice(bytes: &[u8]) -> [i16; 7] {
2319        let mut buf = [0i16; 7];
2320        LittleEndian::read_i16_into(&bytes, &mut buf);
2321        buf
2322    }
2323    fn bytes_expected() -> usize { 14 }
2324}
2325
2326impl ToBytes for [i16; 10] {
2327    fn to_le_byte_vec(arr: [i16; 10]) -> Vec<u8> {
2328        let mut buf = vec![0, 20];
2329        LittleEndian::write_i16_into(&arr, &mut buf);
2330        buf
2331    }
2332}
2333
2334impl FromByteSlice for [i16; 10] {
2335    fn from_le_byte_slice(bytes: &[u8]) -> [i16; 10] {
2336        let mut buf = [0i16; 10];
2337        LittleEndian::read_i16_into(&bytes, &mut buf);
2338        buf
2339    }
2340    fn bytes_expected() -> usize { 20 }
2341}
2342
2343impl ToBytes for [i16; 14] {
2344    fn to_le_byte_vec(arr: [i16; 14]) -> Vec<u8> {
2345        let mut buf = vec![0, 28];
2346        LittleEndian::write_i16_into(&arr, &mut buf);
2347        buf
2348    }
2349}
2350
2351impl FromByteSlice for [i16; 14] {
2352    fn from_le_byte_slice(bytes: &[u8]) -> [i16; 14] {
2353        let mut buf = [0i16; 14];
2354        LittleEndian::read_i16_into(&bytes, &mut buf);
2355        buf
2356    }
2357    fn bytes_expected() -> usize { 28 }
2358}
2359
2360impl ToBytes for [i16; 30] {
2361    fn to_le_byte_vec(arr: [i16; 30]) -> Vec<u8> {
2362        let mut buf = vec![0, 60];
2363        LittleEndian::write_i16_into(&arr, &mut buf);
2364        buf
2365    }
2366}
2367
2368impl FromByteSlice for [i16; 30] {
2369    fn from_le_byte_slice(bytes: &[u8]) -> [i16; 30] {
2370        let mut buf = [0i16; 30];
2371        LittleEndian::read_i16_into(&bytes, &mut buf);
2372        buf
2373    }
2374    fn bytes_expected() -> usize { 60 }
2375}
2376
2377impl ToBytes for [u32; 2] {
2378    fn to_le_byte_vec(arr: [u32; 2]) -> Vec<u8> {
2379        let mut buf = vec![0, 8];
2380        LittleEndian::write_u32_into(&arr, &mut buf);
2381        buf
2382    }
2383}
2384
2385impl FromByteSlice for [u32; 2] {
2386    fn from_le_byte_slice(bytes: &[u8]) -> [u32; 2] {
2387        let mut buf = [0u32; 2];
2388        LittleEndian::read_u32_into(&bytes, &mut buf);
2389        buf
2390    }
2391    fn bytes_expected() -> usize { 8 }
2392}
2393
2394impl ToBytes for [u32; 4] {
2395    fn to_le_byte_vec(arr: [u32; 4]) -> Vec<u8> {
2396        let mut buf = vec![0, 16];
2397        LittleEndian::write_u32_into(&arr, &mut buf);
2398        buf
2399    }
2400}
2401
2402impl FromByteSlice for [u32; 4] {
2403    fn from_le_byte_slice(bytes: &[u8]) -> [u32; 4] {
2404        let mut buf = [0u32; 4];
2405        LittleEndian::read_u32_into(&bytes, &mut buf);
2406        buf
2407    }
2408    fn bytes_expected() -> usize { 16 }
2409}
2410
2411impl ToBytes for [u32; 6] {
2412    fn to_le_byte_vec(arr: [u32; 6]) -> Vec<u8> {
2413        let mut buf = vec![0, 24];
2414        LittleEndian::write_u32_into(&arr, &mut buf);
2415        buf
2416    }
2417}
2418
2419impl FromByteSlice for [u32; 6] {
2420    fn from_le_byte_slice(bytes: &[u8]) -> [u32; 6] {
2421        let mut buf = [0u32; 6];
2422        LittleEndian::read_u32_into(&bytes, &mut buf);
2423        buf
2424    }
2425    fn bytes_expected() -> usize { 24 }
2426}
2427
2428impl ToBytes for [u32; 14] {
2429    fn to_le_byte_vec(arr: [u32; 14]) -> Vec<u8> {
2430        let mut buf = vec![0, 56];
2431        LittleEndian::write_u32_into(&arr, &mut buf);
2432        buf
2433    }
2434}
2435
2436impl FromByteSlice for [u32; 14] {
2437    fn from_le_byte_slice(bytes: &[u8]) -> [u32; 14] {
2438        let mut buf = [0u32; 14];
2439        LittleEndian::read_u32_into(&bytes, &mut buf);
2440        buf
2441    }
2442    fn bytes_expected() -> usize { 56 }
2443}
2444
2445impl ToBytes for [u32; 15] {
2446    fn to_le_byte_vec(arr: [u32; 15]) -> Vec<u8> {
2447        let mut buf = vec![0, 60];
2448        LittleEndian::write_u32_into(&arr, &mut buf);
2449        buf
2450    }
2451}
2452
2453impl FromByteSlice for [u32; 15] {
2454    fn from_le_byte_slice(bytes: &[u8]) -> [u32; 15] {
2455        let mut buf = [0u32; 15];
2456        LittleEndian::read_u32_into(&bytes, &mut buf);
2457        buf
2458    }
2459    fn bytes_expected() -> usize { 60 }
2460}
2461
2462impl ToBytes for [i32; 2] {
2463    fn to_le_byte_vec(arr: [i32; 2]) -> Vec<u8> {
2464        let mut buf = vec![0, 8];
2465        LittleEndian::write_i32_into(&arr, &mut buf);
2466        buf
2467    }
2468}
2469
2470impl FromByteSlice for [i32; 2] {
2471    fn from_le_byte_slice(bytes: &[u8]) -> [i32; 2] {
2472        let mut buf = [0i32; 2];
2473        LittleEndian::read_i32_into(&bytes, &mut buf);
2474        buf
2475    }
2476    fn bytes_expected() -> usize { 8 }
2477}
2478
2479impl ToBytes for [i32; 4] {
2480    fn to_le_byte_vec(arr: [i32; 4]) -> Vec<u8> {
2481        let mut buf = vec![0, 16];
2482        LittleEndian::write_i32_into(&arr, &mut buf);
2483        buf
2484    }
2485}
2486
2487impl FromByteSlice for [i32; 4] {
2488    fn from_le_byte_slice(bytes: &[u8]) -> [i32; 4] {
2489        let mut buf = [0i32; 4];
2490        LittleEndian::read_i32_into(&bytes, &mut buf);
2491        buf
2492    }
2493    fn bytes_expected() -> usize { 16 }
2494}
2495
2496impl ToBytes for [i32; 6] {
2497    fn to_le_byte_vec(arr: [i32; 6]) -> Vec<u8> {
2498        let mut buf = vec![0, 24];
2499        LittleEndian::write_i32_into(&arr, &mut buf);
2500        buf
2501    }
2502}
2503
2504impl FromByteSlice for [i32; 6] {
2505    fn from_le_byte_slice(bytes: &[u8]) -> [i32; 6] {
2506        let mut buf = [0i32; 6];
2507        LittleEndian::read_i32_into(&bytes, &mut buf);
2508        buf
2509    }
2510    fn bytes_expected() -> usize { 24 }
2511}
2512
2513impl ToBytes for [u64; 4] {
2514    fn to_le_byte_vec(arr: [u64; 4]) -> Vec<u8> {
2515        let mut buf = vec![0, 32];
2516        LittleEndian::write_u64_into(&arr, &mut buf);
2517        buf
2518    }
2519}
2520
2521impl FromByteSlice for [u64; 4] {
2522    fn from_le_byte_slice(bytes: &[u8]) -> [u64; 4] {
2523        let mut buf = [0u64; 4];
2524        LittleEndian::read_u64_into(&bytes, &mut buf);
2525        buf
2526    }
2527    fn bytes_expected() -> usize { 32 }
2528}
2529
2530impl ToBytes for [u64; 7] {
2531    fn to_le_byte_vec(arr: [u64; 7]) -> Vec<u8> {
2532        let mut buf = vec![0, 56];
2533        LittleEndian::write_u64_into(&arr, &mut buf);
2534        buf
2535    }
2536}
2537
2538impl FromByteSlice for [u64; 7] {
2539    fn from_le_byte_slice(bytes: &[u8]) -> [u64; 7] {
2540        let mut buf = [0u64; 7];
2541        LittleEndian::read_u64_into(&bytes, &mut buf);
2542        buf
2543    }
2544    fn bytes_expected() -> usize { 56 }
2545}
2546
2547impl ToBytes for [i64; 4] {
2548    fn to_le_byte_vec(arr: [i64; 4]) -> Vec<u8> {
2549        let mut buf = vec![0, 32];
2550        LittleEndian::write_i64_into(&arr, &mut buf);
2551        buf
2552    }
2553}
2554
2555impl FromByteSlice for [i64; 4] {
2556    fn from_le_byte_slice(bytes: &[u8]) -> [i64; 4] {
2557        let mut buf = [0i64; 4];
2558        LittleEndian::read_i64_into(&bytes, &mut buf);
2559        buf
2560    }
2561    fn bytes_expected() -> usize { 32 }
2562}
2563
2564impl ToBytes for [f32; 3] {
2565    fn to_le_byte_vec(arr: [f32; 3]) -> Vec<u8> {
2566        let mut buf = vec![0, 12];
2567        LittleEndian::write_f32_into(&arr, &mut buf);
2568        buf
2569    }
2570}
2571
2572impl FromByteSlice for [f32; 3] {
2573    fn from_le_byte_slice(bytes: &[u8]) -> [f32; 3] {
2574        let mut buf = [0f32; 3];
2575        LittleEndian::read_f32_into_unchecked(&bytes, &mut buf);
2576        buf
2577    }
2578    fn bytes_expected() -> usize { 12 }
2579}
2580
2581impl ToBytes for [f32; 15] {
2582    fn to_le_byte_vec(arr: [f32; 15]) -> Vec<u8> {
2583        let mut buf = vec![0, 60];
2584        LittleEndian::write_f32_into(&arr, &mut buf);
2585        buf
2586    }
2587}
2588
2589impl FromByteSlice for [f32; 15] {
2590    fn from_le_byte_slice(bytes: &[u8]) -> [f32; 15] {
2591        let mut buf = [0f32; 15];
2592        LittleEndian::read_f32_into_unchecked(&bytes, &mut buf);
2593        buf
2594    }
2595    fn bytes_expected() -> usize { 60 }
2596}
tinkerforge/byte_converter.rs

tinkerforge/
byte_converter.rs
