asn1_rs/asn1_types/sequence/
vec.rs

1use crate::*;
2#[cfg(not(feature = "std"))]
3use alloc::vec::Vec;
4use core::convert::TryFrom;
5use core::fmt::Debug;
6
7use self::debug::{macros::debug_eprintln, trace, trace_generic};
8
9// // XXX this compiles but requires bound TryFrom :/
10// impl<'a, 'b, T> TryFrom<&'b Any<'a>> for Vec<T>
11// where
12//     T: TryFrom<&'b Any<'a>>,
13//     for<'e> <T as TryFrom<&'b Any<'a>>>::Error: From<Error>,
14//     T: FromBer<'a, <T as TryFrom<&'b Any<'a>>>::Error>,
15//     //     T: FromBer<'a, E>,
16//     //     E: From<Error>,
17// {
18//     type Error = <T as TryFrom<&'b Any<'a>>>::Error;
19
20//     fn try_from(any: &'b Any<'a>) -> Result<Vec<T>, Self::Error> {
21//         any.tag().assert_eq(Self::TAG)?;
22//         any.header.assert_constructed()?;
23//         let v = SequenceIterator::<T, BerParser, Self::Error>::new(any.data)
24//             .collect::<Result<Vec<T>, Self::Error>>()?;
25//         Ok(v)
26//     }
27// }
28
29// // XXX this compiles but requires bound TryFrom :/
30// impl<'a, 'b, T> TryFrom<&'b Any<'a>> for Vec<T>
31// where
32//     T: TryFrom<&'b Any<'a>>,
33//     <T as TryFrom<&'b Any<'a>>>::Error: From<Error>,
34//     T: FromBer<'a, <T as TryFrom<&'b Any<'a>>>::Error>,
35//     //     T: FromBer<'a, E>,
36//     //     E: From<Error>,
37// {
38//     type Error = <T as TryFrom<&'b Any<'a>>>::Error;
39
40//     fn try_from(any: &'b Any<'a>) -> Result<Vec<T>, Self::Error> {
41//         any.tag().assert_eq(Self::TAG)?;
42//         any.header.assert_constructed()?;
43//         let v = SequenceIterator::<T, BerParser, Self::Error>::new(any.data)
44//             .collect::<Result<Vec<T>, Self::Error>>()?;
45//         Ok(v)
46//     }
47// }
48
49impl<'a, T> TryFrom<Any<'a>> for Vec<T>
50where
51    T: FromBer<'a>,
52{
53    type Error = Error;
54
55    fn try_from(any: Any<'a>) -> Result<Self> {
56        trace_generic(
57            core::any::type_name::<Self>(),
58            "T::from(Any)",
59            |any| {
60                any.tag().assert_eq(Self::TAG)?;
61                any.header.assert_constructed()?;
62                let res_items: Result<Vec<T>> =
63                    SetIterator::<T, BerParser>::new(any.data).collect();
64                if res_items.is_err() {
65                    debug_eprintln!(
66                        core::any::type_name::<T>(),
67                        "≠ {}",
68                        "Conversion from Any failed".red()
69                    );
70                }
71                res_items
72            },
73            any,
74        )
75    }
76}
77
78impl<T> CheckDerConstraints for Vec<T>
79where
80    T: CheckDerConstraints,
81{
82    fn check_constraints(any: &Any) -> Result<()> {
83        any.tag().assert_eq(Self::TAG)?;
84        any.header.assert_constructed()?;
85        for item in SequenceIterator::<Any, DerParser>::new(any.data) {
86            let item = item?;
87            <T as CheckDerConstraints>::check_constraints(&item)?;
88        }
89        Ok(())
90    }
91}
92
93impl<T> Tagged for Vec<T> {
94    const TAG: Tag = Tag::Sequence;
95}
96
97// impl<'a, T> FromBer<'a> for Vec<T>
98// where
99//     T: FromBer<'a>,
100// {
101//     fn from_ber(bytes: &'a [u8]) -> ParseResult<Self> {
102//         let (rem, any) = Any::from_ber(bytes)?;
103//         any.header.assert_tag(Self::TAG)?;
104//         let v = SequenceIterator::<T, BerParser>::new(any.data).collect::<Result<Vec<T>>>()?;
105//         Ok((rem, v))
106//     }
107// }
108
109/// manual impl of FromDer, so we do not need to require `TryFrom<Any> + CheckDerConstraints`
110impl<'a, T, E> FromDer<'a, E> for Vec<T>
111where
112    T: FromDer<'a, E>,
113    E: From<Error> + Debug,
114{
115    fn from_der(bytes: &'a [u8]) -> ParseResult<Self, E> {
116        trace_generic(
117            core::any::type_name::<Self>(),
118            "Sequence::from_der",
119            |bytes| {
120                let (rem, any) = trace(core::any::type_name::<Self>(), parse_der_any, bytes)
121                    .map_err(Err::convert)?;
122                any.header
123                    .assert_tag(Self::TAG)
124                    .map_err(|e| Err::Error(e.into()))?;
125                let v = SequenceIterator::<T, DerParser, E>::new(any.data)
126                    .collect::<Result<Vec<T>, E>>()
127                    .map_err(Err::Error)?;
128                Ok((rem, v))
129            },
130            bytes,
131        )
132    }
133}
134
135#[cfg(feature = "std")]
136impl<T> ToDer for Vec<T>
137where
138    T: ToDer,
139{
140    fn to_der_len(&self) -> Result<usize> {
141        let mut len = 0;
142        for t in self.iter() {
143            len += t.to_der_len()?;
144        }
145        let header = Header::new(Class::Universal, true, Self::TAG, Length::Definite(len));
146        Ok(header.to_der_len()? + len)
147    }
148
149    fn write_der_header(&self, writer: &mut dyn std::io::Write) -> SerializeResult<usize> {
150        let mut len = 0;
151        for t in self.iter() {
152            len += t.to_der_len().map_err(|_| SerializeError::InvalidLength)?;
153        }
154        let header = Header::new(Class::Universal, true, Self::TAG, Length::Definite(len));
155        header.write_der_header(writer).map_err(Into::into)
156    }
157
158    fn write_der_content(&self, writer: &mut dyn std::io::Write) -> SerializeResult<usize> {
159        let mut sz = 0;
160        for t in self.iter() {
161            sz += t.write_der(writer)?;
162        }
163        Ok(sz)
164    }
165}
asn1_rs/asn1_types/sequence/vec.rs

asn1_rs/asn1_types/sequence/
vec.rs
