Add heapless::Vec-backed SequenceOf and SetOf (#2229)

This reverts commit 48cb730 (#2220)

We already have a `heapless` feature, so might as well use it as the
backing implementation for these types.

This restores the previously removed `SequenceOf` and `SetOf` types,
using `heapless::Vec` as their internal data structure.

Closes #2218

Author: tarcieri

.github/workflows/der.yml

@@ -91,7 +91,16 @@ jobs:
       - run: cargo hack test --feature-powerset --exclude-features arbitrary,std,heapless
       - run: cargo test --features arbitrary
       - run: cargo test --features std
-      #- run: cargo test --all-features # TODO(tarcieri): test heapless
+
+  # Test `heapless` feature (requires MSRV 1.87)
+  test-heapless:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: 1.87
+      - run: cargo test --features heapless
 
   derive:
     runs-on: ubuntu-latest

der/src/asn1.rs

@@ -26,9 +26,7 @@ mod private;
 #[cfg(feature = "real")]
 mod real;
 mod sequence;
-#[cfg(feature = "alloc")]
 mod sequence_of;
-#[cfg(feature = "alloc")]
 mod set_of;
 mod teletex_string;
 mod utc_time;
@@ -69,5 +67,14 @@ pub use self::{
     teletex_string::TeletexString,
 };
 
+#[cfg(feature = "heapless")]
+pub use self::{
+    sequence_of::{SequenceOf, SequenceOfIter},
+    set_of::SetOf,
+};
+
+#[cfg(any(feature = "alloc", feature = "heapless"))]
+pub use set_of::SetOfIter;
+
 #[cfg(feature = "oid")]
 pub use const_oid::ObjectIdentifier;

der/src/asn1/context_specific.rs

@@ -30,8 +30,8 @@ mod tests {
     use crate::{Decode, Encode, SliceReader, TagMode, TagNumber, asn1::BitStringRef};
     use hex_literal::hex;
 
-    #[cfg(feature = "alloc")]
-    use crate::asn1::{ContextSpecificRef, SetOfVec, Utf8StringRef};
+    #[cfg(feature = "heapless")]
+    use crate::asn1::{ContextSpecificRef, SetOf, Utf8StringRef};
 
     // Public key data from `pkcs8` crate's `ed25519-pkcs8-v2.der`
     const EXAMPLE_BYTES: &[u8] =
@@ -125,13 +125,13 @@ mod tests {
     }
 
     #[test]
-    #[cfg(feature = "alloc")]
+    #[cfg(feature = "heapless")]
     fn context_specific_explicit_ref() {
-        let mut set = SetOfVec::new();
+        let mut set = SetOf::new();
         set.insert(8u16).unwrap();
         set.insert(7u16).unwrap();
 
-        let field = ContextSpecificRef::<SetOfVec<u16>> {
+        let field = ContextSpecificRef::<SetOf<u16, 2>> {
             value: &set,
             tag_number: TagNumber(2),
             tag_mode: TagMode::Explicit,
@@ -148,7 +148,7 @@ mod tests {
         );
 
         let mut reader = SliceReader::new(encoded).unwrap();
-        let field = ContextSpecific::<SetOfVec<u16>>::decode_explicit(&mut reader, TagNumber(2))
+        let field = ContextSpecific::<SetOf<u16, 2>>::decode_explicit(&mut reader, TagNumber(2))
             .unwrap()
             .unwrap();
 
@@ -158,16 +158,16 @@ mod tests {
     }
 
     #[test]
-    #[cfg(feature = "alloc")]
+    #[cfg(feature = "heapless")]
     fn context_specific_implicit_ref() {
         let hello = Utf8StringRef::new("Hello").unwrap();
         let world = Utf8StringRef::new("world").unwrap();
 
-        let mut set = SetOfVec::new();
+        let mut set = SetOf::new();
         set.insert(hello).unwrap();
         set.insert(world).unwrap();
 
-        let field = ContextSpecificRef::<SetOfVec<Utf8StringRef<'_>>> {
+        let field = ContextSpecificRef::<SetOf<Utf8StringRef<'_>, 2>> {
             value: &set,
             tag_number: TagNumber(2),
             tag_mode: TagMode::Implicit,
@@ -185,7 +185,7 @@ mod tests {
         );
 
         let mut reader = SliceReader::new(encoded).unwrap();
-        let field = ContextSpecific::<SetOfVec<Utf8StringRef<'_>>>::decode_implicit(
+        let field = ContextSpecific::<SetOf<Utf8StringRef<'_>, 2>>::decode_implicit(
             &mut reader,
             TagNumber(2),
         )

der/src/asn1/sequence_of.rs

@@ -1,13 +1,178 @@
 //! ASN.1 `SEQUENCE OF` support.
 
 use crate::{
-    Decode, DecodeValue, DerOrd, Encode, EncodeValue, Error, FixedTag, Header, Length, Reader, Tag,
-    ValueOrd, Writer, ord::iter_cmp,
+    DerOrd, Encode, EncodeValue, Error, FixedTag, Length, Tag, ValueOrd, Writer, ord::iter_cmp,
 };
 use core::cmp::Ordering;
 
+#[cfg(any(feature = "alloc", feature = "heapless"))]
+use crate::{Decode, DecodeValue, Header, Reader};
 #[cfg(feature = "alloc")]
 use alloc::vec::Vec;
+#[cfg(feature = "heapless")]
+use {crate::ErrorKind, core::slice};
+
+/// ASN.1 `SEQUENCE OF` backed by an array.
+///
+/// This type implements an append-only `SEQUENCE OF` type which is stack-based
+/// and does not depend on `alloc` support.
+// TODO(tarcieri): use `ArrayVec` when/if it's merged into `core` (rust-lang/rfcs#3316)
+#[cfg(feature = "heapless")]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct SequenceOf<T, const N: usize> {
+    inner: heapless::Vec<T, N>,
+}
+
+#[cfg(feature = "heapless")]
+impl<T, const N: usize> SequenceOf<T, N> {
+    /// Create a new [`SequenceOf`].
+    pub fn new() -> Self {
+        Self {
+            inner: heapless::Vec::new(),
+        }
+    }
+
+    /// Add an element to this [`SequenceOf`].
+    pub fn add(&mut self, element: T) -> Result<(), Error> {
+        self.inner
+            .push(element)
+            .map_err(|_| ErrorKind::Overlength.into())
+    }
+
+    /// Borrow the elements of this [`SequenceOf`] as a slice.
+    pub fn as_slice(&self) -> &[T] {
+        self.inner.as_slice()
+    }
+
+    /// Borrow the elements of this [`SequenceOf`] mutably as a slice.
+    pub fn as_mut_slice(&mut self) -> &mut [T] {
+        self.inner.as_mut_slice()
+    }
+
+    /// Get an element of this [`SequenceOf`].
+    pub fn get(&self, index: usize) -> Option<&T> {
+        self.inner.get(index)
+    }
+
+    /// Extract the inner `heapless::Vec`.
+    pub fn into_inner(self) -> heapless::Vec<T, N> {
+        self.inner
+    }
+
+    /// Iterate over the elements in this [`SequenceOf`].
+    pub fn iter(&self) -> SequenceOfIter<'_, T> {
+        SequenceOfIter {
+            inner: self.inner.iter(),
+        }
+    }
+
+    /// Is this [`SequenceOf`] empty?
+    pub fn is_empty(&self) -> bool {
+        self.inner.is_empty()
+    }
+
+    /// Number of elements in this [`SequenceOf`].
+    pub fn len(&self) -> usize {
+        self.inner.len()
+    }
+}
+
+#[cfg(feature = "heapless")]
+impl<T, const N: usize> AsRef<[T]> for SequenceOf<T, N> {
+    fn as_ref(&self) -> &[T] {
+        self.as_slice()
+    }
+}
+
+#[cfg(feature = "heapless")]
+impl<T, const N: usize> AsMut<[T]> for SequenceOf<T, N> {
+    fn as_mut(&mut self) -> &mut [T] {
+        self.as_mut_slice()
+    }
+}
+
+#[cfg(feature = "heapless")]
+impl<T, const N: usize> Default for SequenceOf<T, N> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[cfg(feature = "heapless")]
+impl<'a, T, const N: usize> DecodeValue<'a> for SequenceOf<T, N>
+where
+    T: Decode<'a>,
+{
+    type Error = T::Error;
+
+    fn decode_value<R: Reader<'a>>(reader: &mut R, _header: Header) -> Result<Self, Self::Error> {
+        let mut sequence_of = Self::new();
+
+        while !reader.is_finished() {
+            sequence_of.add(T::decode(reader)?)?;
+        }
+
+        Ok(sequence_of)
+    }
+}
+
+#[cfg(feature = "heapless")]
+impl<T, const N: usize> EncodeValue for SequenceOf<T, N>
+where
+    T: Encode,
+{
+    fn value_len(&self) -> Result<Length, Error> {
+        self.iter()
+            .try_fold(Length::ZERO, |len, elem| len + elem.encoded_len()?)
+    }
+
+    fn encode_value(&self, writer: &mut impl Writer) -> Result<(), Error> {
+        for elem in self.iter() {
+            elem.encode(writer)?;
+        }
+
+        Ok(())
+    }
+}
+
+#[cfg(feature = "heapless")]
+impl<T, const N: usize> FixedTag for SequenceOf<T, N> {
+    const TAG: Tag = Tag::Sequence;
+}
+
+#[cfg(feature = "heapless")]
+impl<T, const N: usize> ValueOrd for SequenceOf<T, N>
+where
+    T: DerOrd,
+{
+    fn value_cmp(&self, other: &Self) -> Result<Ordering, Error> {
+        iter_cmp(self.iter(), other.iter())
+    }
+}
+
+/// Iterator over the elements of an [`SequenceOf`].
+#[cfg(feature = "heapless")]
+#[derive(Clone, Debug)]
+pub struct SequenceOfIter<'a, T> {
+    /// Inner iterator.
+    inner: slice::Iter<'a, T>,
+}
+
+#[cfg(feature = "heapless")]
+impl<'a, T: 'a> Iterator for SequenceOfIter<'a, T> {
+    type Item = &'a T;
+
+    fn next(&mut self) -> Option<&'a T> {
+        self.inner.next()
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.inner.size_hint()
+    }
+}
+
+#[cfg(feature = "heapless")]
+impl<'a, T: 'a> ExactSizeIterator for SequenceOfIter<'a, T> {}
 
 impl<T: Encode> EncodeValue for [T] {
     fn value_len(&self) -> Result<Length, Error> {
@@ -24,6 +189,49 @@ impl<T: Encode> EncodeValue for [T] {
     }
 }
 
+#[cfg(feature = "heapless")]
+impl<'a, T, const N: usize> DecodeValue<'a> for [T; N]
+where
+    T: Decode<'a>,
+{
+    type Error = T::Error;
+
+    fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self, Self::Error> {
+        let sequence_of = SequenceOf::<T, N>::decode_value(reader, header)?;
+        sequence_of
+            .inner
+            .into_array()
+            .map_err(|_| reader.error(Self::TAG.length_error()).into())
+    }
+}
+
+impl<T, const N: usize> EncodeValue for [T; N]
+where
+    T: Encode,
+{
+    fn value_len(&self) -> Result<Length, Error> {
+        self.iter()
+            .try_fold(Length::ZERO, |len, elem| len + elem.encoded_len()?)
+    }
+
+    fn encode_value(&self, writer: &mut impl Writer) -> Result<(), Error> {
+        self.as_slice().encode_value(writer)
+    }
+}
+
+impl<T, const N: usize> FixedTag for [T; N] {
+    const TAG: Tag = Tag::Sequence;
+}
+
+impl<T, const N: usize> ValueOrd for [T; N]
+where
+    T: DerOrd,
+{
+    fn value_cmp(&self, other: &Self) -> Result<Ordering, Error> {
+        iter_cmp(self.iter(), other.iter())
+    }
+}
+
 #[cfg(feature = "alloc")]
 impl<'a, T> DecodeValue<'a> for Vec<T>
 where
@@ -71,3 +279,28 @@ where
         iter_cmp(self.iter(), other.iter())
     }
 }
+
+#[cfg(all(test, feature = "heapless"))]
+mod tests {
+    use super::SequenceOf;
+    use crate::ord::DerOrd;
+
+    #[test]
+    fn sequenceof_valueord_value_cmp() {
+        use core::cmp::Ordering;
+
+        let arr1 = {
+            let mut arr: SequenceOf<u16, 2> = SequenceOf::new();
+            arr.add(0u16).expect("element to be added");
+            arr.add(2u16).expect("element to be added");
+            arr
+        };
+        let arr2 = {
+            let mut arr: SequenceOf<u16, 2> = SequenceOf::new();
+            arr.add(0u16).expect("element to be added");
+            arr.add(1u16).expect("element to be added");
+            arr
+        };
+        assert_eq!(arr1.der_cmp(&arr2), Ok(Ordering::Greater));
+    }
+}