/rust/registry/src/index.crates.io-1949cf8c6b5b557f/yasna-0.5.2/src/serializer/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::{DERWriter,construct_der};
use super::models::ObjectIdentifier;
#[cfg(feature = "time")]
use super::models::{UTCTime,GeneralizedTime};

/// Types encodable in DER.
///
/// # Examples
///
/// ```
/// use yasna;
/// let der = yasna::encode_der::<i64>(&65535);
/// assert_eq!(&der, &[2, 3, 0, 255, 255]);
/// ```
///
/// # Limitations
///
/// Rust types don't correspond to ASN.1 types one-to-one. Not all kinds
/// of ASN.1 types can be encoded via default `DEREncodable` implementation.
///
/// If you want to encode ASN.1, you may implement `DEREncodable` for your
/// own types or use [`construct_der`].
///
/// # Default implementations
///
/// - The encoder for `Vec<T>`/`[T]` is implemented as SEQUENCE OF encoder.
/// - `()` as NULL encoder.
/// - Tuples (except `()`) as SEQUENCE encoder.
/// - `Vec<u8>`/`[u8]` as OCTETSTRING encoder.
/// - `BitVec` as BITSTRING encoder.
/// - `String`/`str` as UTF8String encoder.
/// - `i64`, `u64`, `i32`, `u32`, `i16`, `u16`, `BigInt`, `BigUint`
///   as INTEGER encoder. (`u8` is avoided because of confliction.)
/// - `bool` as BOOLEAN encoder.
/// - `ObjectIdentifier` as OBJECTT IDENTIFIER encoder.
/// - `UTCTime`/`GeneralizedTime` as UTCTime/GeneralizedTime encoder.
pub trait DEREncodable {
    /// Writes the value as an DER-encoded ASN.1 value.
    ///
    /// # Examples
    ///
    /// ```
    /// use yasna::{DEREncodable,DERWriter};
    /// struct Entry {
    ///     name: String,
    ///     age: i64,
    /// }
    ///
    /// impl DEREncodable for Entry {
    ///     fn encode_der(&self, writer: DERWriter) {
    ///         writer.write_sequence(|writer| {
    ///             writer.next().write_visible_string(&self.name);
    ///             writer.next().write_i64(self.age);
    ///         })
    ///     }
    /// }
    /// fn main() {
    ///     let entry = Entry {
    ///         name: String::from("John"),
    ///         age: 32,
    ///     };
    ///     let der = yasna::encode_der(&entry);
    ///     assert_eq!(&der, &[48, 9, 26, 4, 74, 111, 104, 110, 2, 1, 32]);
    /// }
    /// ```
    fn encode_der<'a>(&self, writer: DERWriter<'a>);
}

/// Encodes a value to DER-encoded ASN.1 data.
pub fn encode_der<T:DEREncodable>(value: &T) -> Vec<u8> {
    construct_der(|writer| {
        value.encode_der(writer)
    })
}

impl<T> DEREncodable for Vec<T> where T: DEREncodable {
    fn encode_der(&self, writer: DERWriter) {
        writer.write_sequence(|writer| {
            for elem in self.iter() {
                elem.encode_der(writer.next());
            }
        })
    }
}

impl<T> DEREncodable for [T] where T: DEREncodable {
    fn encode_der(&self, writer: DERWriter) {
        writer.write_sequence(|writer| {
            for elem in self.iter() {
                elem.encode_der(writer.next());
            }
        })
    }
}

impl DEREncodable for i64 {
    fn encode_der(&self, writer: DERWriter) {
        writer.write_i64(*self)
    }
}

impl DEREncodable for u64 {
    fn encode_der(&self, writer: DERWriter) {
        writer.write_u64(*self)
    }
}

impl DEREncodable for i32 {
    fn encode_der(&self, writer: DERWriter) {
        writer.write_i32(*self)
    }
}

impl DEREncodable for u32 {
    fn encode_der(&self, writer: DERWriter) {
        writer.write_u32(*self)
    }
}

impl DEREncodable for i16 {
    fn encode_der(&self, writer: DERWriter) {
        writer.write_i16(*self)
    }
}

impl DEREncodable for u16 {
    fn encode_der(&self, writer: DERWriter) {
        writer.write_u16(*self)
    }
}

#[cfg(feature = "num-bigint")]
impl DEREncodable for BigInt {
    fn encode_der(&self, writer: DERWriter) {
        writer.write_bigint(self)
    }
}

#[cfg(feature = "num-bigint")]
impl DEREncodable for BigUint {
    fn encode_der(&self, writer: DERWriter) {
        writer.write_biguint(self)
    }
}

impl DEREncodable for bool {
    fn encode_der(&self, writer: DERWriter) {
        writer.write_bool(*self)
    }
}

#[cfg(feature = "bit-vec")]
impl DEREncodable for BitVec {
    fn encode_der(&self, writer: DERWriter) {
        writer.write_bitvec(self)
    }
}

impl DEREncodable for Vec<u8> {
    fn encode_der(&self, writer: DERWriter) {
        writer.write_bytes(self)
    }
}

impl DEREncodable for [u8] {
    fn encode_der(&self, writer: DERWriter) {
        writer.write_bytes(self)
    }
}

impl DEREncodable for String {
    fn encode_der(&self, writer: DERWriter) {
        writer.write_utf8string(self)
    }
}

impl DEREncodable for str {
    fn encode_der(&self, writer: DERWriter) {
        writer.write_utf8string(self)
    }
}

impl DEREncodable for ObjectIdentifier {
    fn encode_der(&self, writer: DERWriter) {
        writer.write_oid(self)
    }
}

#[cfg(feature = "time")]
impl DEREncodable for UTCTime {
    fn encode_der(&self, writer: DERWriter) {
        writer.write_utctime(self)
    }
}

#[cfg(feature = "time")]
impl DEREncodable for GeneralizedTime{
    fn encode_der(&self, writer: DERWriter) {
        writer.write_generalized_time(self)
    }
}

impl DEREncodable for () {
    fn encode_der(&self, writer: DERWriter) {
        writer.write_null()
    }
}

impl<T0> DEREncodable for (T0,) where T0: DEREncodable {
    fn encode_der(&self, writer: DERWriter) {
        writer.write_sequence(|writer| {
            self.0.encode_der(writer.next());
        })
    }
}

impl<T0, T1> DEREncodable for (T0, T1)
        where T0: DEREncodable, T1: DEREncodable {
    fn encode_der(&self, writer: DERWriter) {
        writer.write_sequence(|writer| {
            self.0.encode_der(writer.next());
            self.1.encode_der(writer.next());
        })
    }
}

impl<T0, T1, T2> DEREncodable for (T0, T1, T2)
        where T0: DEREncodable, T1: DEREncodable, T2: DEREncodable {
    fn encode_der(&self, writer: DERWriter) {
        writer.write_sequence(|writer| {
            self.0.encode_der(writer.next());
            self.1.encode_der(writer.next());
            self.2.encode_der(writer.next());
        })
    }
}

impl<T0, T1, T2, T3> DEREncodable for (T0, T1, T2, T3)
        where T0: DEREncodable, T1: DEREncodable, T2: DEREncodable,
            T3: DEREncodable {
    fn encode_der(&self, writer: DERWriter) {
        writer.write_sequence(|writer| {
            self.0.encode_der(writer.next());
            self.1.encode_der(writer.next());
            self.2.encode_der(writer.next());
            self.3.encode_der(writer.next());
        })
    }
}

impl<T0, T1, T2, T3, T4> DEREncodable for (T0, T1, T2, T3, T4)
        where T0: DEREncodable, T1: DEREncodable, T2: DEREncodable,
            T3: DEREncodable, T4: DEREncodable {
    fn encode_der(&self, writer: DERWriter) {
        writer.write_sequence(|writer| {
            self.0.encode_der(writer.next());
            self.1.encode_der(writer.next());
            self.2.encode_der(writer.next());
            self.3.encode_der(writer.next());
            self.4.encode_der(writer.next());
        })
    }
}

impl<T0, T1, T2, T3, T4, T5> DEREncodable for (T0, T1, T2, T3, T4, T5)
        where T0: DEREncodable, T1: DEREncodable, T2: DEREncodable,
            T3: DEREncodable, T4: DEREncodable, T5: DEREncodable {
    fn encode_der(&self, writer: DERWriter) {
        writer.write_sequence(|writer| {
            self.0.encode_der(writer.next());
            self.1.encode_der(writer.next());
            self.2.encode_der(writer.next());
            self.3.encode_der(writer.next());
            self.4.encode_der(writer.next());
            self.5.encode_der(writer.next());
        })
    }
}

impl<T0, T1, T2, T3, T4, T5, T6> DEREncodable for (T0, T1, T2, T3, T4, T5, T6)
        where T0: DEREncodable, T1: DEREncodable, T2: DEREncodable,
            T3: DEREncodable, T4: DEREncodable, T5: DEREncodable,
            T6: DEREncodable {
    fn encode_der(&self, writer: DERWriter) {
        writer.write_sequence(|writer| {
            self.0.encode_der(writer.next());
            self.1.encode_der(writer.next());
            self.2.encode_der(writer.next());
            self.3.encode_der(writer.next());
            self.4.encode_der(writer.next());
            self.5.encode_der(writer.next());
            self.6.encode_der(writer.next());
        })
    }
}

impl<T0, T1, T2, T3, T4, T5, T6, T7> DEREncodable
        for (T0, T1, T2, T3, T4, T5, T6, T7)
        where T0: DEREncodable, T1: DEREncodable, T2: DEREncodable,
            T3: DEREncodable, T4: DEREncodable, T5: DEREncodable,
            T6: DEREncodable, T7: DEREncodable {
    fn encode_der(&self, writer: DERWriter) {
        writer.write_sequence(|writer| {
            self.0.encode_der(writer.next());
            self.1.encode_der(writer.next());
            self.2.encode_der(writer.next());
            self.3.encode_der(writer.next());
            self.4.encode_der(writer.next());
            self.5.encode_der(writer.next());
            self.6.encode_der(writer.next());
            self.7.encode_der(writer.next());
        })
    }
}

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> DEREncodable
        for (T0, T1, T2, T3, T4, T5, T6, T7, T8)
        where T0: DEREncodable, T1: DEREncodable, T2: DEREncodable,
            T3: DEREncodable, T4: DEREncodable, T5: DEREncodable,
            T6: DEREncodable, T7: DEREncodable, T8: DEREncodable {
    fn encode_der(&self, writer: DERWriter) {
        writer.write_sequence(|writer| {
            self.0.encode_der(writer.next());
            self.1.encode_der(writer.next());
            self.2.encode_der(writer.next());
            self.3.encode_der(writer.next());
            self.4.encode_der(writer.next());
            self.5.encode_der(writer.next());
            self.6.encode_der(writer.next());
            self.7.encode_der(writer.next());
            self.8.encode_der(writer.next());
        })
    }
}

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> DEREncodable
        for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)
        where T0: DEREncodable, T1: DEREncodable, T2: DEREncodable,
            T3: DEREncodable, T4: DEREncodable, T5: DEREncodable,
            T6: DEREncodable, T7: DEREncodable, T8: DEREncodable,
            T9: DEREncodable {
    fn encode_der(&self, writer: DERWriter) {
        writer.write_sequence(|writer| {
            self.0.encode_der(writer.next());
            self.1.encode_der(writer.next());
            self.2.encode_der(writer.next());
            self.3.encode_der(writer.next());
            self.4.encode_der(writer.next());
            self.5.encode_der(writer.next());
            self.6.encode_der(writer.next());
            self.7.encode_der(writer.next());
            self.8.encode_der(writer.next());
            self.9.encode_der(writer.next());
        })
    }
}

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> DEREncodable
        for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)
        where T0: DEREncodable, T1: DEREncodable, T2: DEREncodable,
            T3: DEREncodable, T4: DEREncodable, T5: DEREncodable,
            T6: DEREncodable, T7: DEREncodable, T8: DEREncodable,
            T9: DEREncodable, T10: DEREncodable {
    fn encode_der(&self, writer: DERWriter) {
        writer.write_sequence(|writer| {
            self.0.encode_der(writer.next());
            self.1.encode_der(writer.next());
            self.2.encode_der(writer.next());
            self.3.encode_der(writer.next());
            self.4.encode_der(writer.next());
            self.5.encode_der(writer.next());
            self.6.encode_der(writer.next());
            self.7.encode_der(writer.next());
            self.8.encode_der(writer.next());
            self.9.encode_der(writer.next());
            self.10.encode_der(writer.next());
        })
    }
}

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> DEREncodable
        for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)
        where T0: DEREncodable, T1: DEREncodable, T2: DEREncodable,
            T3: DEREncodable, T4: DEREncodable, T5: DEREncodable,
            T6: DEREncodable, T7: DEREncodable, T8: DEREncodable,
            T9: DEREncodable, T10: DEREncodable, T11: DEREncodable {
    fn encode_der(&self, writer: DERWriter) {
        writer.write_sequence(|writer| {
            self.0.encode_der(writer.next());
            self.1.encode_der(writer.next());
            self.2.encode_der(writer.next());
            self.3.encode_der(writer.next());
            self.4.encode_der(writer.next());
            self.5.encode_der(writer.next());
            self.6.encode_der(writer.next());
            self.7.encode_der(writer.next());
            self.8.encode_der(writer.next());
            self.9.encode_der(writer.next());
            self.10.encode_der(writer.next());
            self.11.encode_der(writer.next());
        })
    }
}

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::{DERWriter,construct_der};
20		use super::models::ObjectIdentifier;
21		#[cfg(feature = "time")]
22		use super::models::{UTCTime,GeneralizedTime};
23
24		/// Types encodable in DER.
25		///
26		/// # Examples
27		///
28		/// ```
29		/// use yasna;
30		/// let der = yasna::encode_der::<i64>(&65535);
31		/// assert_eq!(&der, &[2, 3, 0, 255, 255]);
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 encoded via default `DEREncodable` implementation.
38		///
39		/// If you want to encode ASN.1, you may implement `DEREncodable` for your
40		/// own types or use [`construct_der`].
41		///
42		/// # Default implementations
43		///
44		/// - The encoder for `Vec<T>`/`[T]` is implemented as SEQUENCE OF encoder.
45		/// - `()` as NULL encoder.
46		/// - Tuples (except `()`) as SEQUENCE encoder.
47		/// - `Vec<u8>`/`[u8]` as OCTETSTRING encoder.
48		/// - `BitVec` as BITSTRING encoder.
49		/// - `String`/`str` as UTF8String encoder.
50		/// - `i64`, `u64`, `i32`, `u32`, `i16`, `u16`, `BigInt`, `BigUint`
51		/// as INTEGER encoder. (`u8` is avoided because of confliction.)
52		/// - `bool` as BOOLEAN encoder.
53		/// - `ObjectIdentifier` as OBJECTT IDENTIFIER encoder.
54		/// - `UTCTime`/`GeneralizedTime` as UTCTime/GeneralizedTime encoder.
55		pub trait DEREncodable {
56		/// Writes the value as an DER-encoded ASN.1 value.
57		///
58		/// # Examples
59		///
60		/// ```
61		/// use yasna::{DEREncodable,DERWriter};
62		/// struct Entry {
63		/// name: String,
64		/// age: i64,
65		/// }
66		///
67		/// impl DEREncodable for Entry {
68		/// fn encode_der(&self, writer: DERWriter) {
69		/// writer.write_sequence(\|writer\| {
70		/// writer.next().write_visible_string(&self.name);
71		/// writer.next().write_i64(self.age);
72		/// })
73		/// }
74		/// }
75		/// fn main() {
76		/// let entry = Entry {
77		/// name: String::from("John"),
78		/// age: 32,
79		/// };
80		/// let der = yasna::encode_der(&entry);
81		/// assert_eq!(&der, &[48, 9, 26, 4, 74, 111, 104, 110, 2, 1, 32]);
82		/// }
83		/// ```
84		fn encode_der<'a>(&self, writer: DERWriter<'a>);
85		}
86
87		/// Encodes a value to DER-encoded ASN.1 data.
88	0	pub fn encode_der<T:DEREncodable>(value: &T) -> Vec<u8> {
89	0	construct_der(\|writer\| {
90	0	value.encode_der(writer)
91	0	})
92	0	}
93
94		impl<T> DEREncodable for Vec<T> where T: DEREncodable {
95	0	fn encode_der(&self, writer: DERWriter) {
96	0	writer.write_sequence(\|writer\| {
97	0	for elem in self.iter() {
98	0	elem.encode_der(writer.next());
99	0	}
100	0	})
101	0	}
102		}
103
104		impl<T> DEREncodable for [T] where T: DEREncodable {
105	0	fn encode_der(&self, writer: DERWriter) {
106	0	writer.write_sequence(\|writer\| {
107	0	for elem in self.iter() {
108	0	elem.encode_der(writer.next());
109	0	}
110	0	})
111	0	}
112		}
113
114		impl DEREncodable for i64 {
115	0	fn encode_der(&self, writer: DERWriter) {
116	0	writer.write_i64(*self)
117	0	}
118		}
119
120		impl DEREncodable for u64 {
121	0	fn encode_der(&self, writer: DERWriter) {
122	0	writer.write_u64(*self)
123	0	}
124		}
125
126		impl DEREncodable for i32 {
127	0	fn encode_der(&self, writer: DERWriter) {
128	0	writer.write_i32(*self)
129	0	}
130		}
131
132		impl DEREncodable for u32 {
133	0	fn encode_der(&self, writer: DERWriter) {
134	0	writer.write_u32(*self)
135	0	}
136		}
137
138		impl DEREncodable for i16 {
139	0	fn encode_der(&self, writer: DERWriter) {
140	0	writer.write_i16(*self)
141	0	}
142		}
143
144		impl DEREncodable for u16 {
145	0	fn encode_der(&self, writer: DERWriter) {
146	0	writer.write_u16(*self)
147	0	}
148		}
149
150		#[cfg(feature = "num-bigint")]
151		impl DEREncodable for BigInt {
152		fn encode_der(&self, writer: DERWriter) {
153		writer.write_bigint(self)
154		}
155		}
156
157		#[cfg(feature = "num-bigint")]
158		impl DEREncodable for BigUint {
159		fn encode_der(&self, writer: DERWriter) {
160		writer.write_biguint(self)
161		}
162		}
163
164		impl DEREncodable for bool {
165	0	fn encode_der(&self, writer: DERWriter) {
166	0	writer.write_bool(*self)
167	0	}
168		}
169
170		#[cfg(feature = "bit-vec")]
171		impl DEREncodable for BitVec {
172		fn encode_der(&self, writer: DERWriter) {
173		writer.write_bitvec(self)
174		}
175		}
176
177		impl DEREncodable for Vec<u8> {
178	0	fn encode_der(&self, writer: DERWriter) {
179	0	writer.write_bytes(self)
180	0	}
181		}
182
183		impl DEREncodable for [u8] {
184	0	fn encode_der(&self, writer: DERWriter) {
185	0	writer.write_bytes(self)
186	0	}
187		}
188
189		impl DEREncodable for String {
190	0	fn encode_der(&self, writer: DERWriter) {
191	0	writer.write_utf8string(self)
192	0	}
193		}
194
195		impl DEREncodable for str {
196	0	fn encode_der(&self, writer: DERWriter) {
197	0	writer.write_utf8string(self)
198	0	}
199		}
200
201		impl DEREncodable for ObjectIdentifier {
202	0	fn encode_der(&self, writer: DERWriter) {
203	0	writer.write_oid(self)
204	0	}
205		}
206
207		#[cfg(feature = "time")]
208		impl DEREncodable for UTCTime {
209	0	fn encode_der(&self, writer: DERWriter) {
210	0	writer.write_utctime(self)
211	0	}
212		}
213
214		#[cfg(feature = "time")]
215		impl DEREncodable for GeneralizedTime{
216	0	fn encode_der(&self, writer: DERWriter) {
217	0	writer.write_generalized_time(self)
218	0	}
219		}
220
221		impl DEREncodable for () {
222	0	fn encode_der(&self, writer: DERWriter) {
223	0	writer.write_null()
224	0	}
225		}
226
227		impl<T0> DEREncodable for (T0,) where T0: DEREncodable {
228	0	fn encode_der(&self, writer: DERWriter) {
229	0	writer.write_sequence(\|writer\| {
230	0	self.0.encode_der(writer.next());
231	0	})
232	0	}
233		}
234
235		impl<T0, T1> DEREncodable for (T0, T1)
236		where T0: DEREncodable, T1: DEREncodable {
237	0	fn encode_der(&self, writer: DERWriter) {
238	0	writer.write_sequence(\|writer\| {
239	0	self.0.encode_der(writer.next());
240	0	self.1.encode_der(writer.next());
241	0	})
242	0	}
243		}
244
245		impl<T0, T1, T2> DEREncodable for (T0, T1, T2)
246		where T0: DEREncodable, T1: DEREncodable, T2: DEREncodable {
247	0	fn encode_der(&self, writer: DERWriter) {
248	0	writer.write_sequence(\|writer\| {
249	0	self.0.encode_der(writer.next());
250	0	self.1.encode_der(writer.next());
251	0	self.2.encode_der(writer.next());
252	0	})
253	0	}
254		}
255
256		impl<T0, T1, T2, T3> DEREncodable for (T0, T1, T2, T3)
257		where T0: DEREncodable, T1: DEREncodable, T2: DEREncodable,
258		T3: DEREncodable {
259	0	fn encode_der(&self, writer: DERWriter) {
260	0	writer.write_sequence(\|writer\| {
261	0	self.0.encode_der(writer.next());
262	0	self.1.encode_der(writer.next());
263	0	self.2.encode_der(writer.next());
264	0	self.3.encode_der(writer.next());
265	0	})
266	0	}
267		}
268
269		impl<T0, T1, T2, T3, T4> DEREncodable for (T0, T1, T2, T3, T4)
270		where T0: DEREncodable, T1: DEREncodable, T2: DEREncodable,
271		T3: DEREncodable, T4: DEREncodable {
272	0	fn encode_der(&self, writer: DERWriter) {
273	0	writer.write_sequence(\|writer\| {
274	0	self.0.encode_der(writer.next());
275	0	self.1.encode_der(writer.next());
276	0	self.2.encode_der(writer.next());
277	0	self.3.encode_der(writer.next());
278	0	self.4.encode_der(writer.next());
279	0	})
280	0	}
281		}
282
283		impl<T0, T1, T2, T3, T4, T5> DEREncodable for (T0, T1, T2, T3, T4, T5)
284		where T0: DEREncodable, T1: DEREncodable, T2: DEREncodable,
285		T3: DEREncodable, T4: DEREncodable, T5: DEREncodable {
286	0	fn encode_der(&self, writer: DERWriter) {
287	0	writer.write_sequence(\|writer\| {
288	0	self.0.encode_der(writer.next());
289	0	self.1.encode_der(writer.next());
290	0	self.2.encode_der(writer.next());
291	0	self.3.encode_der(writer.next());
292	0	self.4.encode_der(writer.next());
293	0	self.5.encode_der(writer.next());
294	0	})
295	0	}
296		}
297
298		impl<T0, T1, T2, T3, T4, T5, T6> DEREncodable for (T0, T1, T2, T3, T4, T5, T6)
299		where T0: DEREncodable, T1: DEREncodable, T2: DEREncodable,
300		T3: DEREncodable, T4: DEREncodable, T5: DEREncodable,
301		T6: DEREncodable {
302	0	fn encode_der(&self, writer: DERWriter) {
303	0	writer.write_sequence(\|writer\| {
304	0	self.0.encode_der(writer.next());
305	0	self.1.encode_der(writer.next());
306	0	self.2.encode_der(writer.next());
307	0	self.3.encode_der(writer.next());
308	0	self.4.encode_der(writer.next());
309	0	self.5.encode_der(writer.next());
310	0	self.6.encode_der(writer.next());
311	0	})
312	0	}
313		}
314
315		impl<T0, T1, T2, T3, T4, T5, T6, T7> DEREncodable
316		for (T0, T1, T2, T3, T4, T5, T6, T7)
317		where T0: DEREncodable, T1: DEREncodable, T2: DEREncodable,
318		T3: DEREncodable, T4: DEREncodable, T5: DEREncodable,
319		T6: DEREncodable, T7: DEREncodable {
320	0	fn encode_der(&self, writer: DERWriter) {
321	0	writer.write_sequence(\|writer\| {
322	0	self.0.encode_der(writer.next());
323	0	self.1.encode_der(writer.next());
324	0	self.2.encode_der(writer.next());
325	0	self.3.encode_der(writer.next());
326	0	self.4.encode_der(writer.next());
327	0	self.5.encode_der(writer.next());
328	0	self.6.encode_der(writer.next());
329	0	self.7.encode_der(writer.next());
330	0	})
331	0	}
332		}
333
334		impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> DEREncodable
335		for (T0, T1, T2, T3, T4, T5, T6, T7, T8)
336		where T0: DEREncodable, T1: DEREncodable, T2: DEREncodable,
337		T3: DEREncodable, T4: DEREncodable, T5: DEREncodable,
338		T6: DEREncodable, T7: DEREncodable, T8: DEREncodable {
339	0	fn encode_der(&self, writer: DERWriter) {
340	0	writer.write_sequence(\|writer\| {
341	0	self.0.encode_der(writer.next());
342	0	self.1.encode_der(writer.next());
343	0	self.2.encode_der(writer.next());
344	0	self.3.encode_der(writer.next());
345	0	self.4.encode_der(writer.next());
346	0	self.5.encode_der(writer.next());
347	0	self.6.encode_der(writer.next());
348	0	self.7.encode_der(writer.next());
349	0	self.8.encode_der(writer.next());
350	0	})
351	0	}
352		}
353
354		impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> DEREncodable
355		for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)
356		where T0: DEREncodable, T1: DEREncodable, T2: DEREncodable,
357		T3: DEREncodable, T4: DEREncodable, T5: DEREncodable,
358		T6: DEREncodable, T7: DEREncodable, T8: DEREncodable,
359		T9: DEREncodable {
360	0	fn encode_der(&self, writer: DERWriter) {
361	0	writer.write_sequence(\|writer\| {
362	0	self.0.encode_der(writer.next());
363	0	self.1.encode_der(writer.next());
364	0	self.2.encode_der(writer.next());
365	0	self.3.encode_der(writer.next());
366	0	self.4.encode_der(writer.next());
367	0	self.5.encode_der(writer.next());
368	0	self.6.encode_der(writer.next());
369	0	self.7.encode_der(writer.next());
370	0	self.8.encode_der(writer.next());
371	0	self.9.encode_der(writer.next());
372	0	})
373	0	}
374		}
375
376		impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> DEREncodable
377		for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)
378		where T0: DEREncodable, T1: DEREncodable, T2: DEREncodable,
379		T3: DEREncodable, T4: DEREncodable, T5: DEREncodable,
380		T6: DEREncodable, T7: DEREncodable, T8: DEREncodable,
381		T9: DEREncodable, T10: DEREncodable {
382	0	fn encode_der(&self, writer: DERWriter) {
383	0	writer.write_sequence(\|writer\| {
384	0	self.0.encode_der(writer.next());
385	0	self.1.encode_der(writer.next());
386	0	self.2.encode_der(writer.next());
387	0	self.3.encode_der(writer.next());
388	0	self.4.encode_der(writer.next());
389	0	self.5.encode_der(writer.next());
390	0	self.6.encode_der(writer.next());
391	0	self.7.encode_der(writer.next());
392	0	self.8.encode_der(writer.next());
393	0	self.9.encode_der(writer.next());
394	0	self.10.encode_der(writer.next());
395	0	})
396	0	}
397		}
398
399		impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> DEREncodable
400		for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)
401		where T0: DEREncodable, T1: DEREncodable, T2: DEREncodable,
402		T3: DEREncodable, T4: DEREncodable, T5: DEREncodable,
403		T6: DEREncodable, T7: DEREncodable, T8: DEREncodable,
404		T9: DEREncodable, T10: DEREncodable, T11: DEREncodable {
405	0	fn encode_der(&self, writer: DERWriter) {
406	0	writer.write_sequence(\|writer\| {
407	0	self.0.encode_der(writer.next());
408	0	self.1.encode_der(writer.next());
409	0	self.2.encode_der(writer.next());
410	0	self.3.encode_der(writer.next());
411	0	self.4.encode_der(writer.next());
412	0	self.5.encode_der(writer.next());
413	0	self.6.encode_der(writer.next());
414	0	self.7.encode_der(writer.next());
415	0	self.8.encode_der(writer.next());
416	0	self.9.encode_der(writer.next());
417	0	self.10.encode_der(writer.next());
418	0	self.11.encode_der(writer.next());
419	0	})
420	0	}
421		}