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

use crate::{Decoder, DefaultCodec, Encoder, Measurer, error::DecodeError, error::EncodeError};
#[cfg(feature = "alloc")]
use alloc::{vec, vec::Vec};

pub trait DecodeDefault<'encoded>: Sized {
    fn decode(
        encoded: &'encoded [u8],
        offset: &mut usize,
    ) -> Result<Self, crate::error::DecodeError>;
}

impl<'encoded, 'decoded, T> DecodeDefault<'encoded> for T
where
    T: DefaultCodec + 'decoded,
    T::Codec: Decoder<'encoded, 'decoded, Decoded = T>,
{
    fn decode(encoded: &'encoded [u8], offset: &mut usize) -> Result<Self, DecodeError> {
        let codec = T::default_codec();
        codec.decode(encoded, offset)
    }
}

pub trait EncodeDefault {
    fn encode(&self, encoded: &mut [u8], offset: &mut usize) -> Result<(), EncodeError>;
}

impl<T, Codec> EncodeDefault for T
where
    T: DefaultCodec<Codec = Codec> + ?Sized,
    Codec: Encoder<Decoded = T>,
{
    fn encode(&self, encoded: &mut [u8], offset: &mut usize) -> Result<(), EncodeError> {
        let codec = T::default_codec();
        codec.encode(self, encoded, offset)
    }
}

pub trait EncodeToVec {
    #[cfg(feature = "alloc")]
    fn encode_to_vec(&self) -> Result<Vec<u8>, EncodeError>;

    fn encode_to_heapless_vec<const N: usize>(&self) -> Result<heapless::Vec<u8, N>, EncodeError>;
}

impl<T, Codec> EncodeToVec for T
where
    T: DefaultCodec<Codec = Codec> + ?Sized,
    Codec: Encoder<Decoded = T> + Measurer<Decoded = T>,
{
    #[cfg(feature = "alloc")]
    fn encode_to_vec(&self) -> Result<Vec<u8>, EncodeError> {
        let codec = Self::default_codec();
        EncoderToVec::encode_to_vec(&codec, self)
    }

    fn encode_to_heapless_vec<const N: usize>(&self) -> Result<heapless::Vec<u8, N>, EncodeError> {
        let codec = Self::default_codec();
        EncoderToVec::encode_to_heapless_vec(&codec, self)
    }
}

pub trait EncoderToVec {
    type Decoded: ?Sized;

    #[cfg(feature = "alloc")]
    fn encode_to_vec(&self, decoded: &Self::Decoded) -> Result<Vec<u8>, EncodeError>;

    fn encode_to_heapless_vec<const N: usize>(
        &self,
        decoded: &Self::Decoded,
    ) -> Result<heapless::Vec<u8, N>, EncodeError>;
}

impl<Decoded: ?Sized, C: Encoder<Decoded = Decoded> + Measurer<Decoded = Decoded>> EncoderToVec
    for C
{
    type Decoded = Decoded;

    #[cfg(feature = "alloc")]
    fn encode_to_vec(&self, decoded: &Self::Decoded) -> Result<Vec<u8>, crate::error::EncodeError> {
        let size = self.measure(decoded)?;
        let mut vec = vec![0u8; size];
        let mut offset = 0;
        self.encode(decoded, &mut vec, &mut offset)?;
        Ok(vec)
    }

    fn encode_to_heapless_vec<const N: usize>(
        &self,
        decoded: &Self::Decoded,
    ) -> Result<heapless::Vec<u8, N>, crate::error::EncodeError> {
        let size = self.measure(decoded)?;
        if size > N {
            return Err(crate::error::EncodeError::BufferTooSmall);
        }
        let mut vec = heapless::Vec::<u8, N>::new();
        vec.resize_default(size)
            .map_err(|_| crate::error::EncodeError::BufferTooSmall)?;
        let mut offset = 0;
        self.encode(decoded, &mut vec, &mut offset)?;
        Ok(vec)
    }
}