der/asn1/
sequence_of.rs

1//! ASN.1 `SEQUENCE OF` support.
2
3use crate::{
4    DerOrd, Encode, EncodeValue, Error, FixedTag, Length, Tag, ValueOrd, Writer, ord::iter_cmp,
5};
6use core::cmp::Ordering;
7
8#[cfg(any(feature = "alloc", feature = "heapless"))]
9use crate::{Decode, DecodeValue, Header, Reader};
10#[cfg(feature = "alloc")]
11use alloc::vec::Vec;
12#[cfg(feature = "heapless")]
13use {crate::ErrorKind, core::slice};
14
15/// ASN.1 `SEQUENCE OF` backed by an array.
16///
17/// This type implements an append-only `SEQUENCE OF` type which is stack-based
18/// and does not depend on `alloc` support.
19// TODO(tarcieri): use `ArrayVec` when/if it's merged into `core` (rust-lang/rfcs#3316)
20#[cfg(feature = "heapless")]
21#[derive(Clone, Debug, Eq, PartialEq)]
22pub struct SequenceOf<T, const N: usize> {
23    inner: heapless::Vec<T, N>,
24}
25
26#[cfg(feature = "heapless")]
27impl<T, const N: usize> SequenceOf<T, N> {
28    /// Create a new [`SequenceOf`].
29    #[must_use]
30    pub fn new() -> Self {
31        Self {
32            inner: heapless::Vec::new(),
33        }
34    }
35
36    /// Add an element to this [`SequenceOf`].
37    ///
38    /// # Errors
39    /// If this sequence is overlength.
40    pub fn add(&mut self, element: T) -> Result<(), Error> {
41        self.inner
42            .push(element)
43            .map_err(|_| ErrorKind::Overlength.into())
44    }
45
46    /// Borrow the elements of this [`SequenceOf`] as a slice.
47    pub fn as_slice(&self) -> &[T] {
48        self.inner.as_slice()
49    }
50
51    /// Borrow the elements of this [`SequenceOf`] mutably as a slice.
52    pub fn as_mut_slice(&mut self) -> &mut [T] {
53        self.inner.as_mut_slice()
54    }
55
56    /// Get an element of this [`SequenceOf`].
57    pub fn get(&self, index: usize) -> Option<&T> {
58        self.inner.get(index)
59    }
60
61    /// Extract the inner `heapless::Vec`.
62    pub fn into_inner(self) -> heapless::Vec<T, N> {
63        self.inner
64    }
65
66    /// Iterate over the elements in this [`SequenceOf`].
67    pub fn iter(&self) -> SequenceOfIter<'_, T> {
68        SequenceOfIter {
69            inner: self.inner.iter(),
70        }
71    }
72
73    /// Is this [`SequenceOf`] empty?
74    pub fn is_empty(&self) -> bool {
75        self.inner.is_empty()
76    }
77
78    /// Number of elements in this [`SequenceOf`].
79    pub fn len(&self) -> usize {
80        self.inner.len()
81    }
82}
83
84#[cfg(feature = "heapless")]
85impl<T, const N: usize> AsRef<[T]> for SequenceOf<T, N> {
86    fn as_ref(&self) -> &[T] {
87        self.as_slice()
88    }
89}
90
91#[cfg(feature = "heapless")]
92impl<T, const N: usize> AsMut<[T]> for SequenceOf<T, N> {
93    fn as_mut(&mut self) -> &mut [T] {
94        self.as_mut_slice()
95    }
96}
97
98#[cfg(feature = "heapless")]
99impl<T, const N: usize> Default for SequenceOf<T, N> {
100    fn default() -> Self {
101        Self::new()
102    }
103}
104
105#[cfg(feature = "heapless")]
106impl<'a, T, const N: usize> DecodeValue<'a> for SequenceOf<T, N>
107where
108    T: Decode<'a>,
109{
110    type Error = T::Error;
111
112    fn decode_value<R: Reader<'a>>(reader: &mut R, _header: Header) -> Result<Self, Self::Error> {
113        let mut sequence_of = Self::new();
114
115        while !reader.is_finished() {
116            sequence_of.add(T::decode(reader)?)?;
117        }
118
119        Ok(sequence_of)
120    }
121}
122
123#[cfg(feature = "heapless")]
124impl<T, const N: usize> EncodeValue for SequenceOf<T, N>
125where
126    T: Encode,
127{
128    fn value_len(&self) -> Result<Length, Error> {
129        self.iter()
130            .try_fold(Length::ZERO, |len, elem| len + elem.encoded_len()?)
131    }
132
133    fn encode_value(&self, writer: &mut impl Writer) -> Result<(), Error> {
134        for elem in self.iter() {
135            elem.encode(writer)?;
136        }
137
138        Ok(())
139    }
140}
141
142#[cfg(feature = "heapless")]
143impl<T, const N: usize> FixedTag for SequenceOf<T, N> {
144    const TAG: Tag = Tag::Sequence;
145}
146
147#[cfg(feature = "heapless")]
148impl<T, const N: usize> ValueOrd for SequenceOf<T, N>
149where
150    T: DerOrd,
151{
152    fn value_cmp(&self, other: &Self) -> Result<Ordering, Error> {
153        iter_cmp(self.iter(), other.iter())
154    }
155}
156
157/// Iterator over the elements of an [`SequenceOf`].
158#[cfg(feature = "heapless")]
159#[derive(Clone, Debug)]
160pub struct SequenceOfIter<'a, T> {
161    /// Inner iterator.
162    inner: slice::Iter<'a, T>,
163}
164
165#[cfg(feature = "heapless")]
166impl<'a, T: 'a> Iterator for SequenceOfIter<'a, T> {
167    type Item = &'a T;
168
169    fn next(&mut self) -> Option<&'a T> {
170        self.inner.next()
171    }
172
173    fn size_hint(&self) -> (usize, Option<usize>) {
174        self.inner.size_hint()
175    }
176}
177
178#[cfg(feature = "heapless")]
179impl<'a, T: 'a> ExactSizeIterator for SequenceOfIter<'a, T> {}
180
181impl<T: Encode> EncodeValue for [T] {
182    fn value_len(&self) -> Result<Length, Error> {
183        self.iter()
184            .try_fold(Length::ZERO, |len, elem| len + elem.encoded_len()?)
185    }
186
187    fn encode_value(&self, writer: &mut impl Writer) -> Result<(), Error> {
188        for elem in self {
189            elem.encode(writer)?;
190        }
191
192        Ok(())
193    }
194}
195
196#[cfg(feature = "heapless")]
197impl<'a, T, const N: usize> DecodeValue<'a> for [T; N]
198where
199    T: Decode<'a>,
200{
201    type Error = T::Error;
202
203    fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self, Self::Error> {
204        let sequence_of = SequenceOf::<T, N>::decode_value(reader, header)?;
205        sequence_of
206            .inner
207            .into_array()
208            .map_err(|_| reader.error(Self::TAG.length_error()).into())
209    }
210}
211
212impl<T, const N: usize> EncodeValue for [T; N]
213where
214    T: Encode,
215{
216    fn value_len(&self) -> Result<Length, Error> {
217        self.iter()
218            .try_fold(Length::ZERO, |len, elem| len + elem.encoded_len()?)
219    }
220
221    fn encode_value(&self, writer: &mut impl Writer) -> Result<(), Error> {
222        self.as_slice().encode_value(writer)
223    }
224}
225
226impl<T, const N: usize> FixedTag for [T; N] {
227    const TAG: Tag = Tag::Sequence;
228}
229
230impl<T, const N: usize> ValueOrd for [T; N]
231where
232    T: DerOrd,
233{
234    fn value_cmp(&self, other: &Self) -> Result<Ordering, Error> {
235        iter_cmp(self.iter(), other.iter())
236    }
237}
238
239#[cfg(feature = "alloc")]
240impl<'a, T> DecodeValue<'a> for Vec<T>
241where
242    T: Decode<'a>,
243{
244    type Error = T::Error;
245
246    fn decode_value<R: Reader<'a>>(reader: &mut R, _header: Header) -> Result<Self, Self::Error> {
247        let mut sequence_of = Vec::<T>::new();
248
249        while !reader.is_finished() {
250            sequence_of.push(T::decode(reader)?);
251        }
252
253        Ok(sequence_of)
254    }
255}
256
257#[cfg(feature = "alloc")]
258impl<T> EncodeValue for Vec<T>
259where
260    T: Encode,
261{
262    fn value_len(&self) -> Result<Length, Error> {
263        self.iter()
264            .try_fold(Length::ZERO, |len, elem| len + elem.encoded_len()?)
265    }
266
267    fn encode_value(&self, writer: &mut impl Writer) -> Result<(), Error> {
268        self.as_slice().encode_value(writer)
269    }
270}
271
272#[cfg(feature = "alloc")]
273impl<T> FixedTag for Vec<T> {
274    const TAG: Tag = Tag::Sequence;
275}
276
277#[cfg(feature = "alloc")]
278impl<T> ValueOrd for Vec<T>
279where
280    T: DerOrd,
281{
282    fn value_cmp(&self, other: &Self) -> Result<Ordering, Error> {
283        iter_cmp(self.iter(), other.iter())
284    }
285}
286
287#[cfg(all(test, feature = "heapless"))]
288mod tests {
289    use super::SequenceOf;
290    use crate::ord::DerOrd;
291
292    #[test]
293    fn sequenceof_valueord_value_cmp() {
294        use core::cmp::Ordering;
295
296        let arr1 = {
297            let mut arr: SequenceOf<u16, 2> = SequenceOf::new();
298            arr.add(0u16).expect("element to be added");
299            arr.add(2u16).expect("element to be added");
300            arr
301        };
302        let arr2 = {
303            let mut arr: SequenceOf<u16, 2> = SequenceOf::new();
304            arr.add(0u16).expect("element to be added");
305            arr.add(1u16).expect("element to be added");
306            arr
307        };
308        assert_eq!(arr1.der_cmp(&arr2), Ok(Ordering::Greater));
309    }
310}
der/asn1/sequence_of.rs

der/asn1/
sequence_of.rs
