byten 0.0.13

A binary codec library for efficient encoding and decoding of data structures
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

use crate::{Decoder, Encoder, FixedMeasurer, Measurer, error::DecodeError, error::EncodeError};

/// A codec for fixed-size arrays of fixed/dynamic sized elements.
///
/// The size must be a compile-time constant.
/// However, the elements themselves do not need to be of fixed size.
///
/// The item codec is used to encode, decode and measure each element of the array.
///
/// # Examples
/// ```rust
/// use byten::{ArrayCodec, Encoder, FixedMeasurer, Measurer, Decoder, EncodeError, EndianCodec};
///
/// let codec = ArrayCodec::new(EndianCodec::<u32>::le());
/// let array: [u32; 4] = [1, 2, 3, 4];
///
/// let mut encoded = [0u8; 16];
/// let mut offset = 0;
/// codec.encode(&array, &mut encoded, &mut offset).unwrap();
/// assert_eq!(offset, 16);
///
/// let mut decode_offset = 0;
/// let decoded: [u32; 4] = codec.decode(&encoded, &mut decode_offset).unwrap();
/// assert_eq!(decoded, array);
/// assert_eq!(decode_offset, 16);
///
/// let size = codec.measure(&array).unwrap();
/// assert_eq!(size, 16);
///
/// let fixed_size = codec.measure_fixed();
/// assert_eq!(fixed_size, 16);
/// ```
pub struct ArrayCodec<Item, const N: usize>(pub Item);

impl<Item, const N: usize> ArrayCodec<Item, N> {
    pub const fn new(item: Item) -> Self {
        Self(item)
    }
}

impl<'encoded, 'decoded, Item, const N: usize> Decoder<'encoded, 'decoded> for ArrayCodec<Item, N>
where
    Item: Decoder<'encoded, 'decoded>,
{
    type Decoded = [Item::Decoded; N];

    fn decode(
        &self,
        encoded: &'encoded [u8],
        offset: &mut usize,
    ) -> Result<Self::Decoded, DecodeError> {
        let mut array: heapless::Vec<Item::Decoded, N> = heapless::Vec::new();
        for _ in 0..N {
            let item = self.0.decode(encoded, offset)?;
            array
                .push(item)
                .unwrap_or_else(|_| panic!("unexpected heapless vec overflow"));
        }
        let array = array
            .into_array()
            .unwrap_or_else(|_| panic!("unexpected heapless vec underflow"));
        Ok(array)
    }
}

impl<Item, const N: usize> Encoder for ArrayCodec<Item, N>
where
    Item: Encoder,
    Item::Decoded: Sized,
{
    type Decoded = [Item::Decoded; N];

    fn encode(
        &self,
        decoded: &Self::Decoded,
        encoded: &mut [u8],
        offset: &mut usize,
    ) -> Result<(), EncodeError> {
        for item in decoded.iter() {
            self.0.encode(item, encoded, offset)?;
        }
        Ok(())
    }
}

impl<Item, const N: usize> FixedMeasurer for ArrayCodec<Item, N>
where
    Item: FixedMeasurer,
    Item::Decoded: Sized,
{
    fn measure_fixed(&self) -> usize {
        N * self.0.measure_fixed()
    }
}

impl<Item, const N: usize> Measurer for ArrayCodec<Item, N>
where
    Item: Measurer,
    Item::Decoded: Sized,
{
    type Decoded = [Item::Decoded; N];

    fn measure(&self, decoded: &Self::Decoded) -> Result<usize, EncodeError> {
        let mut total = 0;
        for item in decoded.iter() {
            total += self.0.measure(item)?;
        }
        Ok(total)
    }
}