asn1_rs/asn1_types/set/
set_of.rs

1use crate::*;
2#[cfg(not(feature = "std"))]
3use alloc::vec::Vec;
4use core::convert::TryFrom;
5use core::fmt::{Debug, Display};
6use core::iter::FromIterator;
7use core::ops::{Deref, DerefMut};
8
9use self::debug::{trace, trace_generic};
10
11/// The `SET OF` object is an unordered list of homogeneous types.
12///
13/// This type implements `Deref<Target = [T]>` and `DerefMut<Target = [T]>`, so all methods
14/// like `.iter()`, `.len()` and others can be used transparently as if using a vector.
15///
16/// # Examples
17///
18/// ```
19/// use asn1_rs::SetOf;
20/// use std::iter::FromIterator;
21///
22/// // build set
23/// let set = SetOf::from_iter([2, 3, 4]);
24///
25/// // `set` now contains the serialized DER representation of the array
26///
27/// // iterate objects
28/// let mut sum = 0;
29/// for item in set.iter() {
30///     // item has type `Result<u32>`, since parsing the serialized bytes could fail
31///     sum += *item;
32/// }
33/// assert_eq!(sum, 9);
34///
35/// ```
36#[derive(Debug, PartialEq)]
37pub struct SetOf<T> {
38    items: Vec<T>,
39}
40
41impl<T> SetOf<T> {
42    /// Builds a `SET OF` from the provided content
43    #[inline]
44    pub const fn new(items: Vec<T>) -> Self {
45        SetOf { items }
46    }
47
48    /// Converts `self` into a vector without clones or allocation.
49    #[inline]
50    pub fn into_vec(self) -> Vec<T> {
51        self.items
52    }
53
54    /// Appends an element to the back of a collection
55    #[inline]
56    pub fn push(&mut self, item: T) {
57        self.items.push(item)
58    }
59}
60
61impl<T> AsRef<[T]> for SetOf<T> {
62    fn as_ref(&self) -> &[T] {
63        &self.items
64    }
65}
66
67impl<T> AsMut<[T]> for SetOf<T> {
68    fn as_mut(&mut self) -> &mut [T] {
69        &mut self.items
70    }
71}
72
73impl<T> Deref for SetOf<T> {
74    type Target = [T];
75
76    fn deref(&self) -> &Self::Target {
77        &self.items
78    }
79}
80
81impl<T> DerefMut for SetOf<T> {
82    fn deref_mut(&mut self) -> &mut Self::Target {
83        &mut self.items
84    }
85}
86
87impl<T> From<SetOf<T>> for Vec<T> {
88    fn from(set: SetOf<T>) -> Self {
89        set.items
90    }
91}
92
93impl<T> FromIterator<T> for SetOf<T> {
94    fn from_iter<IT: IntoIterator<Item = T>>(iter: IT) -> Self {
95        let items = Vec::from_iter(iter);
96        SetOf::new(items)
97    }
98}
99
100impl<'a, T> TryFrom<Any<'a>> for SetOf<T>
101where
102    T: FromBer<'a>,
103{
104    type Error = Error;
105
106    fn try_from(any: Any<'a>) -> Result<Self> {
107        any.tag().assert_eq(Self::TAG)?;
108        if !any.header.is_constructed() {
109            return Err(Error::ConstructExpected);
110        }
111        let items = SetIterator::<T, BerParser>::new(any.data).collect::<Result<Vec<T>>>()?;
112        Ok(SetOf::new(items))
113    }
114}
115
116impl<T> CheckDerConstraints for SetOf<T>
117where
118    T: CheckDerConstraints,
119{
120    fn check_constraints(any: &Any) -> Result<()> {
121        any.tag().assert_eq(Self::TAG)?;
122        any.header.assert_constructed()?;
123        for item in SetIterator::<Any, DerParser>::new(any.data) {
124            let item = item?;
125            T::check_constraints(&item)?;
126        }
127        Ok(())
128    }
129}
130
131/// manual impl of FromDer, so we do not need to require `TryFrom<Any> + CheckDerConstraints`
132impl<'a, T, E> FromDer<'a, E> for SetOf<T>
133where
134    T: FromDer<'a, E>,
135    E: From<Error> + Display + Debug,
136{
137    fn from_der(bytes: &'a [u8]) -> ParseResult<Self, E> {
138        trace_generic(
139            core::any::type_name::<Self>(),
140            "SetOf::from_der",
141            |bytes| {
142                let (rem, any) = trace(core::any::type_name::<Self>(), Any::from_der, bytes)
143                    .map_err(Err::convert)?;
144                any.header
145                    .assert_tag(Self::TAG)
146                    .map_err(|e| Err::Error(e.into()))?;
147                let items = SetIterator::<T, DerParser, E>::new(any.data)
148                    .collect::<Result<Vec<T>, E>>()
149                    .map_err(Err::Error)?;
150                Ok((rem, SetOf::new(items)))
151            },
152            bytes,
153        )
154    }
155}
156
157impl<T> Tagged for SetOf<T> {
158    const TAG: Tag = Tag::Set;
159}
160
161#[cfg(feature = "std")]
162impl<T> ToDer for SetOf<T>
163where
164    T: ToDer,
165{
166    fn to_der_len(&self) -> Result<usize> {
167        self.items.to_der_len()
168    }
169
170    fn write_der_header(&self, writer: &mut dyn std::io::Write) -> SerializeResult<usize> {
171        // Do not call self.items.write_der_header(), this will encode the wrong tag (items is a Vec)
172        let mut len = 0;
173        for t in self.items.iter() {
174            len += t.to_der_len().map_err(|_| SerializeError::InvalidLength)?;
175        }
176        let header = Header::new(Class::Universal, true, Self::TAG, Length::Definite(len));
177        header.write_der_header(writer).map_err(Into::into)
178    }
179
180    fn write_der_content(&self, writer: &mut dyn std::io::Write) -> SerializeResult<usize> {
181        self.items.write_der_content(writer)
182    }
183}
asn1_rs/asn1_types/set/set_of.rs

asn1_rs/asn1_types/set/
set_of.rs
