/rust/registry/src/index.crates.io-1949cf8c6b5b557f/yasna-0.5.2/src/deserializer/mod.rs

Source
// Copyright 2016 Masaki Hara
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

#![forbid(missing_docs)]

use alloc::vec::Vec;
use alloc::string::String;

#[cfg(feature = "num-bigint")]
use num_bigint::{BigInt,BigUint};
#[cfg(feature = "bit-vec")]
use bit_vec::BitVec;

use super::{ASN1Result,BERMode,BERReader,parse_ber_general};
use super::models::{ObjectIdentifier,TaggedDerValue};
#[cfg(feature = "time")]
use super::models::{UTCTime,GeneralizedTime};

/// Types decodable in BER.
///
/// # Examples
///
/// ```
/// use yasna;
/// let asn : i64 = yasna::decode_der(&[2, 3, 0, 255, 255]).unwrap();
/// assert_eq!(asn, 65535);
/// ```
///
/// # Limitations
///
/// Rust types don't correspond to ASN.1 types one-to-one. Not all kinds
/// of ASN.1 types can be decoded via default `BERDecodable` implementation.
///
/// If you want to decode ASN.1, you may implement `BERDecodable` for your
/// own types or use [`parse_der`](crate::parse_der)/
/// [`parse_ber`](crate::parse_ber).
///
/// # Default implementations
///
/// - The decoder for `Vec<T>` is implemented as SEQUENCE OF decoder.
/// - `()` as NULL decoder.
/// - Tuples (except `()`) as SEQUENCE decoder.
/// - `Vec<u8>` as OCTETSTRING decoder.
/// - `BitVec` as BITSTRING decoder.
/// - `String` as UTF8String decoder.
/// - `i64`, `u64`, `i32`, `u32`, `i16`, `u16`, `BigInt`, `BigUint`
///   as INTEGER decoder. (`u8` is avoided because of confliction.)
/// - `bool` as BOOLEAN decoder.
/// - `ObjectIdentifier` as OBJECTT IDENTIFIER decoder.
/// - `UTCTime`/`GeneralizedTime` as UTCTime/GeneralizedTime decoder.
pub trait BERDecodable: Sized {
    /// Reads an ASN.1 value from `BERReader` and converts it to `Self`.
    ///
    /// # Examples
    ///
    /// ```
    /// use yasna::{BERDecodable,BERReader,ASN1Result};
    /// struct Entry {
    ///     name: String,
    ///     age: i64,
    /// }
    ///
    /// impl BERDecodable for Entry {
    ///     fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
    ///         reader.read_sequence(|reader| {
    ///             let name = reader.next().read_visible_string()?;
    ///             let age = reader.next().read_i64()?;
    ///             return Ok(Entry {
    ///                 name: name,
    ///                 age: age,
    ///             });
    ///         })
    ///     }
    /// }
    /// fn main() {
    ///     let entry : Entry = yasna::decode_der(
    ///         &[48, 9, 26, 4, 74, 111, 104, 110, 2, 1, 32]).unwrap();
    ///     assert_eq!(entry.name, "John");
    ///     assert_eq!(entry.age, 32);
    /// }
    /// ```
    fn decode_ber<'a, 'b>(reader: BERReader<'a, 'b>) -> ASN1Result<Self>;
}

/// Decodes DER/BER-encoded data.
///
/// [`decode_ber`] and [`decode_der`] are shorthands
/// for this function.
pub fn decode_ber_general<T:BERDecodable>(src: &[u8], mode: BERMode)
        -> ASN1Result<T> {
    parse_ber_general(src, mode, |reader| {
        T::decode_ber(reader)
    })
}

/// Reads an ASN.1 value from `&[u8]`.
///
/// If you want to accept only DER-encoded data,
/// use [`decode_der`].
///
/// # Examples
///
/// ```
/// use yasna;
/// let asn : i64 = yasna::decode_ber(&[2, 3, 0, 255, 255]).unwrap();
/// assert_eq!(asn, 65535);
/// ```
pub fn decode_ber<T:BERDecodable>(src: &[u8]) -> ASN1Result<T> {
    decode_ber_general(src, BERMode::Ber)
}

/// Reads an ASN.1 value from `&[u8]`.
///
/// If you want to decode BER-encoded data in general,
/// use [`decode_ber`].
///
/// # Examples
///
/// ```
/// use yasna;
/// let asn : i64 = yasna::decode_der(&[2, 3, 0, 255, 255]).unwrap();
/// assert_eq!(asn, 65535);
/// ```
pub fn decode_der<T:BERDecodable>(src: &[u8]) -> ASN1Result<T> {
    decode_ber_general(src, BERMode::Der)
}

impl<T> BERDecodable for Vec<T> where T: BERDecodable {
    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
        reader.read_sequence(|reader| {
            let mut ret = Vec::new();
            loop {
                let result = reader.read_optional(|reader| {
                    T::decode_ber(reader)
                })?;
                match result {
                    Some(result) => {
                        ret.push(result);
                    },
                    None => {
                        break;
                    }
                };
            }
            return Ok(ret);
        })
    }
}

impl BERDecodable for i64 {
    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
        reader.read_i64()
    }
}

impl BERDecodable for u64 {
    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
        reader.read_u64()
    }
}

impl BERDecodable for i32 {
    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
        reader.read_i32()
    }
}

impl BERDecodable for u32 {
    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
        reader.read_u32()
    }
}

impl BERDecodable for i16 {
    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
        reader.read_i16()
    }
}

impl BERDecodable for u16 {
    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
        reader.read_u16()
    }
}

#[cfg(feature = "num-bigint")]
impl BERDecodable for BigInt {
    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
        reader.read_bigint()
    }
}

#[cfg(feature = "num-bigint")]
impl BERDecodable for BigUint {
    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
        reader.read_biguint()
    }
}

impl BERDecodable for bool {
    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
        reader.read_bool()
    }
}

#[cfg(feature = "bit-vec")]
impl BERDecodable for BitVec {
    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
        reader.read_bitvec()
    }
}

impl BERDecodable for Vec<u8> {
    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
        reader.read_bytes()
    }
}

impl BERDecodable for String {
    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
        reader.read_utf8string()
    }
}

impl BERDecodable for ObjectIdentifier {
    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
        reader.read_oid()
    }
}

#[cfg(feature = "time")]
impl BERDecodable for UTCTime {
    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
        reader.read_utctime()
    }
}

#[cfg(feature = "time")]
impl BERDecodable for GeneralizedTime {
    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
        reader.read_generalized_time()
    }
}

impl BERDecodable for () {
    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
        reader.read_null()
    }
}

impl<T0> BERDecodable for (T0,)
        where T0: BERDecodable {
    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
        reader.read_sequence(|reader| {
            let t0 = T0::decode_ber(reader.next())?;
            return Ok((t0,));
        })
    }
}

impl<T0, T1> BERDecodable for (T0, T1)
        where T0: BERDecodable, T1: BERDecodable {
    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
        reader.read_sequence(|reader| {
            let t0 = T0::decode_ber(reader.next())?;
            let t1 = T1::decode_ber(reader.next())?;
            return Ok((t0, t1));
        })
    }
}

impl<T0, T1, T2> BERDecodable for (T0, T1, T2)
        where T0: BERDecodable, T1: BERDecodable, T2: BERDecodable {
    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
        reader.read_sequence(|reader| {
            let t0 = T0::decode_ber(reader.next())?;
            let t1 = T1::decode_ber(reader.next())?;
            let t2 = T2::decode_ber(reader.next())?;
            return Ok((t0, t1, t2));
        })
    }
}

impl<T0, T1, T2, T3> BERDecodable for (T0, T1, T2, T3)
        where T0: BERDecodable, T1: BERDecodable, T2: BERDecodable,
            T3: BERDecodable {
    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
        reader.read_sequence(|reader| {
            let t0 = T0::decode_ber(reader.next())?;
            let t1 = T1::decode_ber(reader.next())?;
            let t2 = T2::decode_ber(reader.next())?;
            let t3 = T3::decode_ber(reader.next())?;
            return Ok((t0, t1, t2, t3));
        })
    }
}

impl<T0, T1, T2, T3, T4> BERDecodable for (T0, T1, T2, T3, T4)
        where T0: BERDecodable, T1: BERDecodable, T2: BERDecodable,
            T3: BERDecodable, T4: BERDecodable {
    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
        reader.read_sequence(|reader| {
            let t0 = T0::decode_ber(reader.next())?;
            let t1 = T1::decode_ber(reader.next())?;
            let t2 = T2::decode_ber(reader.next())?;
            let t3 = T3::decode_ber(reader.next())?;
            let t4 = T4::decode_ber(reader.next())?;
            return Ok((t0, t1, t2, t3, t4));
        })
    }
}

impl<T0, T1, T2, T3, T4, T5> BERDecodable for (T0, T1, T2, T3, T4, T5)
        where T0: BERDecodable, T1: BERDecodable, T2: BERDecodable,
            T3: BERDecodable, T4: BERDecodable, T5: BERDecodable {
    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
        reader.read_sequence(|reader| {
            let t0 = T0::decode_ber(reader.next())?;
            let t1 = T1::decode_ber(reader.next())?;
            let t2 = T2::decode_ber(reader.next())?;
            let t3 = T3::decode_ber(reader.next())?;
            let t4 = T4::decode_ber(reader.next())?;
            let t5 = T5::decode_ber(reader.next())?;
            return Ok((t0, t1, t2, t3, t4, t5));
        })
    }
}

impl<T0, T1, T2, T3, T4, T5, T6> BERDecodable for (T0, T1, T2, T3, T4, T5, T6)
        where T0: BERDecodable, T1: BERDecodable, T2: BERDecodable,
            T3: BERDecodable, T4: BERDecodable, T5: BERDecodable,
            T6: BERDecodable {
    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
        reader.read_sequence(|reader| {
            let t0 = T0::decode_ber(reader.next())?;
            let t1 = T1::decode_ber(reader.next())?;
            let t2 = T2::decode_ber(reader.next())?;
            let t3 = T3::decode_ber(reader.next())?;
            let t4 = T4::decode_ber(reader.next())?;
            let t5 = T5::decode_ber(reader.next())?;
            let t6 = T6::decode_ber(reader.next())?;
            return Ok((t0, t1, t2, t3, t4, t5, t6));
        })
    }
}

impl<T0, T1, T2, T3, T4, T5, T6, T7> BERDecodable
        for (T0, T1, T2, T3, T4, T5, T6, T7)
        where T0: BERDecodable, T1: BERDecodable, T2: BERDecodable,
            T3: BERDecodable, T4: BERDecodable, T5: BERDecodable,
            T6: BERDecodable, T7: BERDecodable {
    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
        reader.read_sequence(|reader| {
            let t0 = T0::decode_ber(reader.next())?;
            let t1 = T1::decode_ber(reader.next())?;
            let t2 = T2::decode_ber(reader.next())?;
            let t3 = T3::decode_ber(reader.next())?;
            let t4 = T4::decode_ber(reader.next())?;
            let t5 = T5::decode_ber(reader.next())?;
            let t6 = T6::decode_ber(reader.next())?;
            let t7 = T7::decode_ber(reader.next())?;
            return Ok((t0, t1, t2, t3, t4, t5, t6, t7));
        })
    }
}

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> BERDecodable
        for (T0, T1, T2, T3, T4, T5, T6, T7, T8)
        where T0: BERDecodable, T1: BERDecodable, T2: BERDecodable,
            T3: BERDecodable, T4: BERDecodable, T5: BERDecodable,
            T6: BERDecodable, T7: BERDecodable, T8: BERDecodable {
    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
        reader.read_sequence(|reader| {
            let t0 = T0::decode_ber(reader.next())?;
            let t1 = T1::decode_ber(reader.next())?;
            let t2 = T2::decode_ber(reader.next())?;
            let t3 = T3::decode_ber(reader.next())?;
            let t4 = T4::decode_ber(reader.next())?;
            let t5 = T5::decode_ber(reader.next())?;
            let t6 = T6::decode_ber(reader.next())?;
            let t7 = T7::decode_ber(reader.next())?;
            let t8 = T8::decode_ber(reader.next())?;
            return Ok((t0, t1, t2, t3, t4, t5, t6, t7, t8));
        })
    }
}

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> BERDecodable
        for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)
        where T0: BERDecodable, T1: BERDecodable, T2: BERDecodable,
            T3: BERDecodable, T4: BERDecodable, T5: BERDecodable,
            T6: BERDecodable, T7: BERDecodable, T8: BERDecodable,
            T9: BERDecodable {
    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
        reader.read_sequence(|reader| {
            let t0 = T0::decode_ber(reader.next())?;
            let t1 = T1::decode_ber(reader.next())?;
            let t2 = T2::decode_ber(reader.next())?;
            let t3 = T3::decode_ber(reader.next())?;
            let t4 = T4::decode_ber(reader.next())?;
            let t5 = T5::decode_ber(reader.next())?;
            let t6 = T6::decode_ber(reader.next())?;
            let t7 = T7::decode_ber(reader.next())?;
            let t8 = T8::decode_ber(reader.next())?;
            let t9 = T9::decode_ber(reader.next())?;
            return Ok((t0, t1, t2, t3, t4, t5, t6, t7, t8, t9));
        })
    }
}

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> BERDecodable
        for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)
        where T0: BERDecodable, T1: BERDecodable, T2: BERDecodable,
            T3: BERDecodable, T4: BERDecodable, T5: BERDecodable,
            T6: BERDecodable, T7: BERDecodable, T8: BERDecodable,
            T9: BERDecodable, T10: BERDecodable {
    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
        reader.read_sequence(|reader| {
            let t0 = T0::decode_ber(reader.next())?;
            let t1 = T1::decode_ber(reader.next())?;
            let t2 = T2::decode_ber(reader.next())?;
            let t3 = T3::decode_ber(reader.next())?;
            let t4 = T4::decode_ber(reader.next())?;
            let t5 = T5::decode_ber(reader.next())?;
            let t6 = T6::decode_ber(reader.next())?;
            let t7 = T7::decode_ber(reader.next())?;
            let t8 = T8::decode_ber(reader.next())?;
            let t9 = T9::decode_ber(reader.next())?;
            let t10 = T10::decode_ber(reader.next())?;
            return Ok((t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10));
        })
    }
}

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> BERDecodable
        for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)
        where T0: BERDecodable, T1: BERDecodable, T2: BERDecodable,
            T3: BERDecodable, T4: BERDecodable, T5: BERDecodable,
            T6: BERDecodable, T7: BERDecodable, T8: BERDecodable,
            T9: BERDecodable, T10: BERDecodable, T11: BERDecodable {
    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
        reader.read_sequence(|reader| {
            let t0 = T0::decode_ber(reader.next())?;
            let t1 = T1::decode_ber(reader.next())?;
            let t2 = T2::decode_ber(reader.next())?;
            let t3 = T3::decode_ber(reader.next())?;
            let t4 = T4::decode_ber(reader.next())?;
            let t5 = T5::decode_ber(reader.next())?;
            let t6 = T6::decode_ber(reader.next())?;
            let t7 = T7::decode_ber(reader.next())?;
            let t8 = T8::decode_ber(reader.next())?;
            let t9 = T9::decode_ber(reader.next())?;
            let t10 = T10::decode_ber(reader.next())?;
            let t11 = T11::decode_ber(reader.next())?;
            return Ok((t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11));
        })
    }
}

impl BERDecodable for TaggedDerValue  {
    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
        reader.read_tagged_der()
    }
}

Coverage Report

Created: 2025-10-29 07:05

Line	Count	Source
1		// Copyright 2016 Masaki Hara
2		//
3		// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
4		// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
5		// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
6		// option. This file may not be copied, modified, or distributed
7		// except according to those terms.
8
9		#![forbid(missing_docs)]
10
11		use alloc::vec::Vec;
12		use alloc::string::String;
13
14		#[cfg(feature = "num-bigint")]
15		use num_bigint::{BigInt,BigUint};
16		#[cfg(feature = "bit-vec")]
17		use bit_vec::BitVec;
18
19		use super::{ASN1Result,BERMode,BERReader,parse_ber_general};
20		use super::models::{ObjectIdentifier,TaggedDerValue};
21		#[cfg(feature = "time")]
22		use super::models::{UTCTime,GeneralizedTime};
23
24		/// Types decodable in BER.
25		///
26		/// # Examples
27		///
28		/// ```
29		/// use yasna;
30		/// let asn : i64 = yasna::decode_der(&[2, 3, 0, 255, 255]).unwrap();
31		/// assert_eq!(asn, 65535);
32		/// ```
33		///
34		/// # Limitations
35		///
36		/// Rust types don't correspond to ASN.1 types one-to-one. Not all kinds
37		/// of ASN.1 types can be decoded via default `BERDecodable` implementation.
38		///
39		/// If you want to decode ASN.1, you may implement `BERDecodable` for your
40		/// own types or use [`parse_der`](crate::parse_der)/
41		/// [`parse_ber`](crate::parse_ber).
42		///
43		/// # Default implementations
44		///
45		/// - The decoder for `Vec<T>` is implemented as SEQUENCE OF decoder.
46		/// - `()` as NULL decoder.
47		/// - Tuples (except `()`) as SEQUENCE decoder.
48		/// - `Vec<u8>` as OCTETSTRING decoder.
49		/// - `BitVec` as BITSTRING decoder.
50		/// - `String` as UTF8String decoder.
51		/// - `i64`, `u64`, `i32`, `u32`, `i16`, `u16`, `BigInt`, `BigUint`
52		/// as INTEGER decoder. (`u8` is avoided because of confliction.)
53		/// - `bool` as BOOLEAN decoder.
54		/// - `ObjectIdentifier` as OBJECTT IDENTIFIER decoder.
55		/// - `UTCTime`/`GeneralizedTime` as UTCTime/GeneralizedTime decoder.
56		pub trait BERDecodable: Sized {
57		/// Reads an ASN.1 value from `BERReader` and converts it to `Self`.
58		///
59		/// # Examples
60		///
61		/// ```
62		/// use yasna::{BERDecodable,BERReader,ASN1Result};
63		/// struct Entry {
64		/// name: String,
65		/// age: i64,
66		/// }
67		///
68		/// impl BERDecodable for Entry {
69		/// fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
70		/// reader.read_sequence(\|reader\| {
71		/// let name = reader.next().read_visible_string()?;
72		/// let age = reader.next().read_i64()?;
73		/// return Ok(Entry {
74		/// name: name,
75		/// age: age,
76		/// });
77		/// })
78		/// }
79		/// }
80		/// fn main() {
81		/// let entry : Entry = yasna::decode_der(
82		/// &[48, 9, 26, 4, 74, 111, 104, 110, 2, 1, 32]).unwrap();
83		/// assert_eq!(entry.name, "John");
84		/// assert_eq!(entry.age, 32);
85		/// }
86		/// ```
87		fn decode_ber<'a, 'b>(reader: BERReader<'a, 'b>) -> ASN1Result<Self>;
88		}
89
90		/// Decodes DER/BER-encoded data.
91		///
92		/// [`decode_ber`] and [`decode_der`] are shorthands
93		/// for this function.
94	0	pub fn decode_ber_general<T:BERDecodable>(src: &[u8], mode: BERMode)
95	0	-> ASN1Result<T> {
96	0	parse_ber_general(src, mode, \|reader\| {
97	0	T::decode_ber(reader)
98	0	})
99	0	}
100
101		/// Reads an ASN.1 value from `&[u8]`.
102		///
103		/// If you want to accept only DER-encoded data,
104		/// use [`decode_der`].
105		///
106		/// # Examples
107		///
108		/// ```
109		/// use yasna;
110		/// let asn : i64 = yasna::decode_ber(&[2, 3, 0, 255, 255]).unwrap();
111		/// assert_eq!(asn, 65535);
112		/// ```
113	0	pub fn decode_ber<T:BERDecodable>(src: &[u8]) -> ASN1Result<T> {
114	0	decode_ber_general(src, BERMode::Ber)
115	0	}
116
117		/// Reads an ASN.1 value from `&[u8]`.
118		///
119		/// If you want to decode BER-encoded data in general,
120		/// use [`decode_ber`].
121		///
122		/// # Examples
123		///
124		/// ```
125		/// use yasna;
126		/// let asn : i64 = yasna::decode_der(&[2, 3, 0, 255, 255]).unwrap();
127		/// assert_eq!(asn, 65535);
128		/// ```
129	0	pub fn decode_der<T:BERDecodable>(src: &[u8]) -> ASN1Result<T> {
130	0	decode_ber_general(src, BERMode::Der)
131	0	}
132
133		impl<T> BERDecodable for Vec<T> where T: BERDecodable {
134	0	fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
135	0	reader.read_sequence(\|reader\| {
136	0	let mut ret = Vec::new();
137		loop {
138	0	let result = reader.read_optional(\|reader\| {
139	0	T::decode_ber(reader)
140	0	})?;
141	0	match result {
142	0	Some(result) => {
143	0	ret.push(result);
144	0	},
145		None => {
146	0	break;
147		}
148		};
149		}
150	0	return Ok(ret);
151	0	})
152	0	}
153		}
154
155		impl BERDecodable for i64 {
156	0	fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
157	0	reader.read_i64()
158	0	}
159		}
160
161		impl BERDecodable for u64 {
162	0	fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
163	0	reader.read_u64()
164	0	}
165		}
166
167		impl BERDecodable for i32 {
168	0	fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
169	0	reader.read_i32()
170	0	}
171		}
172
173		impl BERDecodable for u32 {
174	0	fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
175	0	reader.read_u32()
176	0	}
177		}
178
179		impl BERDecodable for i16 {
180	0	fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
181	0	reader.read_i16()
182	0	}
183		}
184
185		impl BERDecodable for u16 {
186	0	fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
187	0	reader.read_u16()
188	0	}
189		}
190
191		#[cfg(feature = "num-bigint")]
192		impl BERDecodable for BigInt {
193		fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
194		reader.read_bigint()
195		}
196		}
197
198		#[cfg(feature = "num-bigint")]
199		impl BERDecodable for BigUint {
200		fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
201		reader.read_biguint()
202		}
203		}
204
205		impl BERDecodable for bool {
206	0	fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
207	0	reader.read_bool()
208	0	}
209		}
210
211		#[cfg(feature = "bit-vec")]
212		impl BERDecodable for BitVec {
213		fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
214		reader.read_bitvec()
215		}
216		}
217
218		impl BERDecodable for Vec<u8> {
219	0	fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
220	0	reader.read_bytes()
221	0	}
222		}
223
224		impl BERDecodable for String {
225	0	fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
226	0	reader.read_utf8string()
227	0	}
228		}
229
230		impl BERDecodable for ObjectIdentifier {
231	0	fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
232	0	reader.read_oid()
233	0	}
234		}
235
236		#[cfg(feature = "time")]
237		impl BERDecodable for UTCTime {
238	0	fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
239	0	reader.read_utctime()
240	0	}
241		}
242
243		#[cfg(feature = "time")]
244		impl BERDecodable for GeneralizedTime {
245	0	fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
246	0	reader.read_generalized_time()
247	0	}
248		}
249
250		impl BERDecodable for () {
251	0	fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
252	0	reader.read_null()
253	0	}
254		}
255
256		impl<T0> BERDecodable for (T0,)
257		where T0: BERDecodable {
258	0	fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
259	0	reader.read_sequence(\|reader\| {
260	0	let t0 = T0::decode_ber(reader.next())?;
261	0	return Ok((t0,));
262	0	})
263	0	}
264		}
265
266		impl<T0, T1> BERDecodable for (T0, T1)
267		where T0: BERDecodable, T1: BERDecodable {
268	0	fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
269	0	reader.read_sequence(\|reader\| {
270	0	let t0 = T0::decode_ber(reader.next())?;
271	0	let t1 = T1::decode_ber(reader.next())?;
272	0	return Ok((t0, t1));
273	0	})
274	0	}
275		}
276
277		impl<T0, T1, T2> BERDecodable for (T0, T1, T2)
278		where T0: BERDecodable, T1: BERDecodable, T2: BERDecodable {
279	0	fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
280	0	reader.read_sequence(\|reader\| {
281	0	let t0 = T0::decode_ber(reader.next())?;
282	0	let t1 = T1::decode_ber(reader.next())?;
283	0	let t2 = T2::decode_ber(reader.next())?;
284	0	return Ok((t0, t1, t2));
285	0	})
286	0	}
287		}
288
289		impl<T0, T1, T2, T3> BERDecodable for (T0, T1, T2, T3)
290		where T0: BERDecodable, T1: BERDecodable, T2: BERDecodable,
291		T3: BERDecodable {
292	0	fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
293	0	reader.read_sequence(\|reader\| {
294	0	let t0 = T0::decode_ber(reader.next())?;
295	0	let t1 = T1::decode_ber(reader.next())?;
296	0	let t2 = T2::decode_ber(reader.next())?;
297	0	let t3 = T3::decode_ber(reader.next())?;
298	0	return Ok((t0, t1, t2, t3));
299	0	})
300	0	}
301		}
302
303		impl<T0, T1, T2, T3, T4> BERDecodable for (T0, T1, T2, T3, T4)
304		where T0: BERDecodable, T1: BERDecodable, T2: BERDecodable,
305		T3: BERDecodable, T4: BERDecodable {
306	0	fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
307	0	reader.read_sequence(\|reader\| {
308	0	let t0 = T0::decode_ber(reader.next())?;
309	0	let t1 = T1::decode_ber(reader.next())?;
310	0	let t2 = T2::decode_ber(reader.next())?;
311	0	let t3 = T3::decode_ber(reader.next())?;
312	0	let t4 = T4::decode_ber(reader.next())?;
313	0	return Ok((t0, t1, t2, t3, t4));
314	0	})
315	0	}
316		}
317
318		impl<T0, T1, T2, T3, T4, T5> BERDecodable for (T0, T1, T2, T3, T4, T5)
319		where T0: BERDecodable, T1: BERDecodable, T2: BERDecodable,
320		T3: BERDecodable, T4: BERDecodable, T5: BERDecodable {
321	0	fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
322	0	reader.read_sequence(\|reader\| {
323	0	let t0 = T0::decode_ber(reader.next())?;
324	0	let t1 = T1::decode_ber(reader.next())?;
325	0	let t2 = T2::decode_ber(reader.next())?;
326	0	let t3 = T3::decode_ber(reader.next())?;
327	0	let t4 = T4::decode_ber(reader.next())?;
328	0	let t5 = T5::decode_ber(reader.next())?;
329	0	return Ok((t0, t1, t2, t3, t4, t5));
330	0	})
331	0	}
332		}
333
334		impl<T0, T1, T2, T3, T4, T5, T6> BERDecodable for (T0, T1, T2, T3, T4, T5, T6)
335		where T0: BERDecodable, T1: BERDecodable, T2: BERDecodable,
336		T3: BERDecodable, T4: BERDecodable, T5: BERDecodable,
337		T6: BERDecodable {
338	0	fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
339	0	reader.read_sequence(\|reader\| {
340	0	let t0 = T0::decode_ber(reader.next())?;
341	0	let t1 = T1::decode_ber(reader.next())?;
342	0	let t2 = T2::decode_ber(reader.next())?;
343	0	let t3 = T3::decode_ber(reader.next())?;
344	0	let t4 = T4::decode_ber(reader.next())?;
345	0	let t5 = T5::decode_ber(reader.next())?;
346	0	let t6 = T6::decode_ber(reader.next())?;
347	0	return Ok((t0, t1, t2, t3, t4, t5, t6));
348	0	})
349	0	}
350		}
351
352		impl<T0, T1, T2, T3, T4, T5, T6, T7> BERDecodable
353		for (T0, T1, T2, T3, T4, T5, T6, T7)
354		where T0: BERDecodable, T1: BERDecodable, T2: BERDecodable,
355		T3: BERDecodable, T4: BERDecodable, T5: BERDecodable,
356		T6: BERDecodable, T7: BERDecodable {
357	0	fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
358	0	reader.read_sequence(\|reader\| {
359	0	let t0 = T0::decode_ber(reader.next())?;
360	0	let t1 = T1::decode_ber(reader.next())?;
361	0	let t2 = T2::decode_ber(reader.next())?;
362	0	let t3 = T3::decode_ber(reader.next())?;
363	0	let t4 = T4::decode_ber(reader.next())?;
364	0	let t5 = T5::decode_ber(reader.next())?;
365	0	let t6 = T6::decode_ber(reader.next())?;
366	0	let t7 = T7::decode_ber(reader.next())?;
367	0	return Ok((t0, t1, t2, t3, t4, t5, t6, t7));
368	0	})
369	0	}
370		}
371
372		impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> BERDecodable
373		for (T0, T1, T2, T3, T4, T5, T6, T7, T8)
374		where T0: BERDecodable, T1: BERDecodable, T2: BERDecodable,
375		T3: BERDecodable, T4: BERDecodable, T5: BERDecodable,
376		T6: BERDecodable, T7: BERDecodable, T8: BERDecodable {
377	0	fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
378	0	reader.read_sequence(\|reader\| {
379	0	let t0 = T0::decode_ber(reader.next())?;
380	0	let t1 = T1::decode_ber(reader.next())?;
381	0	let t2 = T2::decode_ber(reader.next())?;
382	0	let t3 = T3::decode_ber(reader.next())?;
383	0	let t4 = T4::decode_ber(reader.next())?;
384	0	let t5 = T5::decode_ber(reader.next())?;
385	0	let t6 = T6::decode_ber(reader.next())?;
386	0	let t7 = T7::decode_ber(reader.next())?;
387	0	let t8 = T8::decode_ber(reader.next())?;
388	0	return Ok((t0, t1, t2, t3, t4, t5, t6, t7, t8));
389	0	})
390	0	}
391		}
392
393		impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> BERDecodable
394		for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)
395		where T0: BERDecodable, T1: BERDecodable, T2: BERDecodable,
396		T3: BERDecodable, T4: BERDecodable, T5: BERDecodable,
397		T6: BERDecodable, T7: BERDecodable, T8: BERDecodable,
398		T9: BERDecodable {
399	0	fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
400	0	reader.read_sequence(\|reader\| {
401	0	let t0 = T0::decode_ber(reader.next())?;
402	0	let t1 = T1::decode_ber(reader.next())?;
403	0	let t2 = T2::decode_ber(reader.next())?;
404	0	let t3 = T3::decode_ber(reader.next())?;
405	0	let t4 = T4::decode_ber(reader.next())?;
406	0	let t5 = T5::decode_ber(reader.next())?;
407	0	let t6 = T6::decode_ber(reader.next())?;
408	0	let t7 = T7::decode_ber(reader.next())?;
409	0	let t8 = T8::decode_ber(reader.next())?;
410	0	let t9 = T9::decode_ber(reader.next())?;
411	0	return Ok((t0, t1, t2, t3, t4, t5, t6, t7, t8, t9));
412	0	})
413	0	}
414		}
415
416		impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> BERDecodable
417		for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)
418		where T0: BERDecodable, T1: BERDecodable, T2: BERDecodable,
419		T3: BERDecodable, T4: BERDecodable, T5: BERDecodable,
420		T6: BERDecodable, T7: BERDecodable, T8: BERDecodable,
421		T9: BERDecodable, T10: BERDecodable {
422	0	fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
423	0	reader.read_sequence(\|reader\| {
424	0	let t0 = T0::decode_ber(reader.next())?;
425	0	let t1 = T1::decode_ber(reader.next())?;
426	0	let t2 = T2::decode_ber(reader.next())?;
427	0	let t3 = T3::decode_ber(reader.next())?;
428	0	let t4 = T4::decode_ber(reader.next())?;
429	0	let t5 = T5::decode_ber(reader.next())?;
430	0	let t6 = T6::decode_ber(reader.next())?;
431	0	let t7 = T7::decode_ber(reader.next())?;
432	0	let t8 = T8::decode_ber(reader.next())?;
433	0	let t9 = T9::decode_ber(reader.next())?;
434	0	let t10 = T10::decode_ber(reader.next())?;
435	0	return Ok((t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10));
436	0	})
437	0	}
438		}
439
440		impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> BERDecodable
441		for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)
442		where T0: BERDecodable, T1: BERDecodable, T2: BERDecodable,
443		T3: BERDecodable, T4: BERDecodable, T5: BERDecodable,
444		T6: BERDecodable, T7: BERDecodable, T8: BERDecodable,
445		T9: BERDecodable, T10: BERDecodable, T11: BERDecodable {
446	0	fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
447	0	reader.read_sequence(\|reader\| {
448	0	let t0 = T0::decode_ber(reader.next())?;
449	0	let t1 = T1::decode_ber(reader.next())?;
450	0	let t2 = T2::decode_ber(reader.next())?;
451	0	let t3 = T3::decode_ber(reader.next())?;
452	0	let t4 = T4::decode_ber(reader.next())?;
453	0	let t5 = T5::decode_ber(reader.next())?;
454	0	let t6 = T6::decode_ber(reader.next())?;
455	0	let t7 = T7::decode_ber(reader.next())?;
456	0	let t8 = T8::decode_ber(reader.next())?;
457	0	let t9 = T9::decode_ber(reader.next())?;
458	0	let t10 = T10::decode_ber(reader.next())?;
459	0	let t11 = T11::decode_ber(reader.next())?;
460	0	return Ok((t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11));
461	0	})
462	0	}
463		}
464
465		impl BERDecodable for TaggedDerValue {
466	0	fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
467	0	reader.read_tagged_der()
468	0	}
469		}