micropb 0.6.0

Rust Protobuf library targetting embedded systems and no_std environments
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

#[cfg(feature = "decode")]
use crate::decode::{DecodeError, PbDecoder, PbRead};
#[cfg(feature = "encode")]
use crate::encode::{PbEncoder, PbWrite};

#[cfg(feature = "decode")]
/// Protobuf message that can be decoded from the wire.
///
/// Implementations are auto-generated by `micropb-gen`.
pub trait MessageDecode {
    /// Decode an instance of the message from the decoder and merge it into `self`.
    ///
    /// Length of the message needs to be known beforehand.
    fn decode<R: PbRead>(
        &mut self,
        decoder: &mut PbDecoder<R>,
        len: usize,
    ) -> Result<(), DecodeError<R::Error>>;

    /// Decode an instance of the message from the provided bytes
    fn decode_from_bytes(
        &mut self,
        bytes: &[u8],
    ) -> Result<(), DecodeError<core::convert::Infallible>> {
        let mut decoder = PbDecoder::new(bytes);
        self.decode(&mut decoder, bytes.len())
    }

    /// Decode an instance of the message from the decoder as a length-delimited record, starting with a length
    /// prefix.
    fn decode_len_delimited<R: PbRead>(
        &mut self,
        decoder: &mut PbDecoder<R>,
    ) -> Result<(), DecodeError<R::Error>> {
        decoder.decode_len_record(|len, _, decoder| self.decode(decoder, len))
    }
}

#[cfg(feature = "decode")]
impl<T: MessageDecode> MessageDecode for &mut T {
    fn decode<R: PbRead>(
        &mut self,
        decoder: &mut PbDecoder<R>,
        len: usize,
    ) -> Result<(), DecodeError<R::Error>> {
        (*self).decode(decoder, len)
    }

    fn decode_from_bytes(
        &mut self,
        bytes: &[u8],
    ) -> Result<(), DecodeError<core::convert::Infallible>> {
        (*self).decode_from_bytes(bytes)
    }

    fn decode_len_delimited<R: PbRead>(
        &mut self,
        decoder: &mut PbDecoder<R>,
    ) -> Result<(), DecodeError<R::Error>> {
        (*self).decode_len_delimited(decoder)
    }
}

#[cfg(feature = "encode")]
/// Protobuf message that can be encoded onto the wire.
///
/// Implementations are auto-generated by `micropb-gen`.
pub trait MessageEncode {
    /// Maximum encoded size of the message on the wire.
    ///
    /// If `MAX_SIZE` is `Err`, that means the message size is unbounded, due to having custom
    /// fields or collections fields without a fixed capacity, such as `Vec`. The generator will
    /// populate the `Err` with a message indicating the reason.
    ///
    /// The recommended way to use `MAX_SIZE` in const context is via
    /// [`max_encoded_size`](crate::size::max_encoded_size).
    const MAX_SIZE: Result<usize, &'static str>;

    /// Encode this message using the encoder.
    fn encode<W: PbWrite>(&self, encoder: &mut PbEncoder<W>) -> Result<(), W::Error>;

    /// Encode this message as a length-delimited record, starting with a length prefix.
    fn encode_len_delimited<W: PbWrite>(&self, encoder: &mut PbEncoder<W>) -> Result<(), W::Error> {
        encoder.encode_varint32(self.compute_size() as u32)?;
        self.encode(encoder)
    }

    /// Compute the size of this message on the wire.
    fn compute_size(&self) -> usize;
}

#[doc(hidden)]
#[cfg(feature = "encode")]
pub trait MessageEncodeCached {
    const MAX_SIZE: Result<usize, &'static str>;

    type Cache: Default;

    fn populate_cache(&self) -> Self::Cache;

    fn encode_cached<W: PbWrite>(
        &self,
        encoder: &mut PbEncoder<W>,
        cache: &Self::Cache,
    ) -> Result<(), W::Error>;

    fn compute_size_cached(&self, cache: &Self::Cache) -> usize;

    fn encode_len_delimited_cached<W: PbWrite>(
        &self,
        encoder: &mut PbEncoder<W>,
        cache: &Self::Cache,
    ) -> Result<(), W::Error> {
        encoder.encode_varint32(self.compute_size_cached(cache) as u32)?;
        self.encode_cached(encoder, cache)
    }
}

#[cfg(feature = "encode")]
impl<T: MessageEncodeCached> MessageEncode for T {
    const MAX_SIZE: Result<usize, &'static str> = T::MAX_SIZE;

    fn encode<W: PbWrite>(&self, encoder: &mut PbEncoder<W>) -> Result<(), W::Error> {
        let cache = self.populate_cache();
        self.encode_cached(encoder, &cache)
    }

    fn compute_size(&self) -> usize {
        let cache = self.populate_cache();
        self.compute_size_cached(&cache)
    }

    fn encode_len_delimited<W: PbWrite>(&self, encoder: &mut PbEncoder<W>) -> Result<(), W::Error> {
        let cache = self.populate_cache();
        self.encode_len_delimited_cached(encoder, &cache)
    }
}