der: rename SliceReader/SliceWriter

der/src/asn1/any.rs

@@ -1,8 +1,8 @@
 //! ASN.1 `ANY` type.
 
 use crate::{
-    asn1::*, ByteSlice, Choice, Decode, DecodeValue, Decoder, DerOrd, EncodeValue, Error,
-    ErrorKind, FixedTag, Header, Length, Reader, Result, Tag, Tagged, ValueOrd, Writer,
+    asn1::*, ByteSlice, Choice, Decode, DecodeValue, DerOrd, EncodeValue, Error, ErrorKind,
+    FixedTag, Header, Length, Reader, Result, SliceReader, Tag, Tagged, ValueOrd, Writer,
 };
 use core::cmp::Ordering;
 
@@ -66,7 +66,7 @@ impl<'a> AnyRef<'a> {
             length: self.value.len(),
         };
 
-        let mut decoder = Decoder::new(self.value())?;
+        let mut decoder = SliceReader::new(self.value())?;
         let result = T::decode_value(&mut decoder, header)?;
         decoder.finish(result)
     }
@@ -129,15 +129,15 @@ impl<'a> AnyRef<'a> {
     }
 
     /// Attempt to decode this value an ASN.1 `SEQUENCE`, creating a new
-    /// nested [`Decoder`] and calling the provided argument with it.
+    /// nested reader and calling the provided argument with it.
     pub fn sequence<F, T>(self, f: F) -> Result<T>
     where
-        F: FnOnce(&mut Decoder<'a>) -> Result<T>,
+        F: FnOnce(&mut SliceReader<'a>) -> Result<T>,
     {
         self.tag.assert_eq(Tag::Sequence)?;
-        let mut seq_decoder = Decoder::new(self.value.as_slice())?;
-        let result = f(&mut seq_decoder)?;
-        seq_decoder.finish(result)
+        let mut reader = SliceReader::new(self.value.as_slice())?;
+        let result = f(&mut reader)?;
+        reader.finish(result)
     }
 
     /// Attempt to decode an ASN.1 `UTCTime`.

der/src/asn1/context_specific.rs

@@ -256,7 +256,7 @@ where
 #[cfg(test)]
 mod tests {
     use super::ContextSpecific;
-    use crate::{asn1::BitStringRef, Decode, Decoder, Encode, TagMode, TagNumber};
+    use crate::{asn1::BitStringRef, Decode, Encode, SliceReader, TagMode, TagNumber};
     use hex_literal::hex;
 
     // Public key data from `pkcs8` crate's `ed25519-pkcs8-v2.der`
@@ -282,22 +282,22 @@ mod tests {
         let tag_number = TagNumber::new(0);
 
         // Empty message
-        let mut decoder = Decoder::new(&[]).unwrap();
+        let mut reader = SliceReader::new(&[]).unwrap();
         assert_eq!(
-            ContextSpecific::<u8>::decode_explicit(&mut decoder, tag_number).unwrap(),
+            ContextSpecific::<u8>::decode_explicit(&mut reader, tag_number).unwrap(),
             None
         );
 
         // Message containing a non-context-specific type
-        let mut decoder = Decoder::new(&hex!("020100")).unwrap();
+        let mut reader = SliceReader::new(&hex!("020100")).unwrap();
         assert_eq!(
-            ContextSpecific::<u8>::decode_explicit(&mut decoder, tag_number).unwrap(),
+            ContextSpecific::<u8>::decode_explicit(&mut reader, tag_number).unwrap(),
             None
         );
 
         // Message containing an EXPLICIT context-specific field
-        let mut decoder = Decoder::new(&hex!("A003020100")).unwrap();
-        let field = ContextSpecific::<u8>::decode_explicit(&mut decoder, tag_number)
+        let mut reader = SliceReader::new(&hex!("A003020100")).unwrap();
+        let field = ContextSpecific::<u8>::decode_explicit(&mut reader, tag_number)
             .unwrap()
             .unwrap();
 
@@ -319,8 +319,8 @@ mod tests {
 
         let tag_number = TagNumber::new(1);
 
-        let mut decoder = Decoder::new(&context_specific_implicit_bytes).unwrap();
-        let field = ContextSpecific::<BitStringRef<'_>>::decode_implicit(&mut decoder, tag_number)
+        let mut reader = SliceReader::new(&context_specific_implicit_bytes).unwrap();
+        let field = ContextSpecific::<BitStringRef<'_>>::decode_implicit(&mut reader, tag_number)
             .unwrap()
             .unwrap();
 
@@ -335,8 +335,8 @@ mod tests {
     #[test]
     fn context_specific_skipping_unknown_field() {
         let tag = TagNumber::new(1);
-        let mut decoder = Decoder::new(&hex!("A003020100A103020101")).unwrap();
-        let field = ContextSpecific::<u8>::decode_explicit(&mut decoder, tag)
+        let mut reader = SliceReader::new(&hex!("A003020100A103020101")).unwrap();
+        let field = ContextSpecific::<u8>::decode_explicit(&mut reader, tag)
             .unwrap()
             .unwrap();
         assert_eq!(field.value, 1);
@@ -345,9 +345,9 @@ mod tests {
     #[test]
     fn context_specific_returns_none_on_greater_tag_number() {
         let tag = TagNumber::new(0);
-        let mut decoder = Decoder::new(&hex!("A103020101")).unwrap();
+        let mut reader = SliceReader::new(&hex!("A103020101")).unwrap();
         assert_eq!(
-            ContextSpecific::<u8>::decode_explicit(&mut decoder, tag).unwrap(),
+            ContextSpecific::<u8>::decode_explicit(&mut reader, tag).unwrap(),
             None
         );
     }

der/src/asn1/generalized_time.rs

@@ -331,7 +331,7 @@ impl TryFrom<GeneralizedTime> for PrimitiveDateTime {
 #[cfg(test)]
 mod tests {
     use super::GeneralizedTime;
-    use crate::{Decode, Encode, Encoder};
+    use crate::{Decode, Encode, SliceWriter};
     use hex_literal::hex;
 
     #[test]
@@ -341,7 +341,7 @@ mod tests {
         assert_eq!(utc_time.to_unix_duration().as_secs(), 673573540);
 
         let mut buf = [0u8; 128];
-        let mut encoder = Encoder::new(&mut buf);
+        let mut encoder = SliceWriter::new(&mut buf);
         utc_time.encode(&mut encoder).unwrap();
         assert_eq!(example_bytes, encoder.finish().unwrap());
     }

der/src/asn1/integer.rs

@@ -5,8 +5,8 @@ pub(super) mod int;
 pub(super) mod uint;
 
 use crate::{
-    asn1::AnyRef, ByteSlice, DecodeValue, EncodeValue, Encoder, Error, FixedTag, Header, Length,
-    Reader, Result, Tag, ValueOrd, Writer,
+    asn1::AnyRef, ByteSlice, DecodeValue, EncodeValue, Error, FixedTag, Header, Length, Reader,
+    Result, SliceWriter, Tag, ValueOrd, Writer,
 };
 use core::{cmp::Ordering, mem};
 
@@ -140,11 +140,11 @@ where
     debug_assert!(mem::size_of::<T>() <= MAX_INT_SIZE);
 
     let mut buf1 = [0u8; MAX_INT_SIZE];
-    let mut encoder1 = Encoder::new(&mut buf1);
+    let mut encoder1 = SliceWriter::new(&mut buf1);
     a.encode_value(&mut encoder1)?;
 
     let mut buf2 = [0u8; MAX_INT_SIZE];
-    let mut encoder2 = Encoder::new(&mut buf2);
+    let mut encoder2 = SliceWriter::new(&mut buf2);
     b.encode_value(&mut encoder2)?;
 
     Ok(encoder1.finish()?.cmp(encoder2.finish()?))

der/src/asn1/integer/bigint.rs

@@ -97,7 +97,7 @@ mod tests {
     use super::UIntRef;
     use crate::{
         asn1::{integer::tests::*, AnyRef},
-        Decode, Encode, Encoder, ErrorKind, Tag,
+        Decode, Encode, ErrorKind, SliceWriter, Tag,
     };
 
     #[test]
@@ -131,7 +131,7 @@ mod tests {
             let uint = UIntRef::from_der(example).unwrap();
 
             let mut buf = [0u8; 128];
-            let mut encoder = Encoder::new(&mut buf);
+            let mut encoder = SliceWriter::new(&mut buf);
             uint.encode(&mut encoder).unwrap();
 
             let result = encoder.finish().unwrap();

der/src/asn1/utc_time.rs

@@ -198,7 +198,7 @@ impl TryFrom<AnyRef<'_>> for UtcTime {
 #[cfg(test)]
 mod tests {
     use super::UtcTime;
-    use crate::{Decode, Encode, Encoder};
+    use crate::{Decode, Encode, SliceWriter};
     use hex_literal::hex;
 
     #[test]
@@ -208,7 +208,7 @@ mod tests {
         assert_eq!(utc_time.to_unix_duration().as_secs(), 673573540);
 
         let mut buf = [0u8; 128];
-        let mut encoder = Encoder::new(&mut buf);
+        let mut encoder = SliceWriter::new(&mut buf);
         utc_time.encode(&mut encoder).unwrap();
         assert_eq!(example_bytes, encoder.finish().unwrap());
     }

der/src/decode.rs

@@ -1,6 +1,6 @@
 //! Trait definition for [`Decode`].
 
-use crate::{Decoder, FixedTag, Header, Reader, Result};
+use crate::{FixedTag, Header, Reader, Result, SliceReader};
 
 #[cfg(feature = "pem")]
 use crate::{pem::PemLabel, PemReader};
@@ -18,9 +18,9 @@ pub trait Decode<'a>: Sized {
 
     /// Parse `Self` from the provided DER-encoded byte slice.
     fn from_der(bytes: &'a [u8]) -> Result<Self> {
-        let mut decoder = Decoder::new(bytes)?;
-        let result = Self::decode(&mut decoder)?;
-        decoder.finish(result)
+        let mut reader = SliceReader::new(bytes)?;
+        let result = Self::decode(&mut reader)?;
+        reader.finish(result)
     }
 }
 
@@ -71,6 +71,6 @@ impl<T: DecodeOwned + PemLabel> DecodePem for T {
 /// Decode the value part of a Tag-Length-Value encoded field, sans the [`Tag`]
 /// and [`Length`].
 pub trait DecodeValue<'a>: Sized {
-    /// Attempt to decode this message using the provided [`Decoder`].
-    fn decode_value<R: Reader<'a>>(decoder: &mut R, header: Header) -> Result<Self>;
+    /// Attempt to decode this message using the provided [`Reader`].
+    fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self>;
 }

der/src/document.rs

@@ -1,6 +1,6 @@
 //! ASN.1 DER-encoded documents stored on the heap.
 
-use crate::{Decode, Decoder, Encode, Error, FixedTag, Length, Reader, Result, Tag, Writer};
+use crate::{Decode, Encode, Error, FixedTag, Length, Reader, Result, SliceReader, Tag, Writer};
 use alloc::vec::Vec;
 use core::fmt::{self, Debug};
 
@@ -187,7 +187,7 @@ impl TryFrom<Vec<u8>> for Document {
     type Error = Error;
 
     fn try_from(der_bytes: Vec<u8>) -> Result<Self> {
-        let mut decoder = Decoder::new(&der_bytes)?;
+        let mut decoder = SliceReader::new(&der_bytes)?;
         decode_sequence(&mut decoder)?;
         decoder.finish(())?;
 
@@ -331,7 +331,7 @@ impl ZeroizeOnDrop for SecretDocument {}
 
 /// Attempt to decode a ASN.1 `SEQUENCE` from the given decoder, returning the
 /// entire sequence including the header.
-fn decode_sequence<'a>(decoder: &mut Decoder<'a>) -> Result<&'a [u8]> {
+fn decode_sequence<'a>(decoder: &mut SliceReader<'a>) -> Result<&'a [u8]> {
     let header = decoder.peek_header()?;
     header.tag.assert_eq(Tag::Sequence)?;
 

der/src/encode.rs

@@ -1,6 +1,6 @@
 //! Trait definition for [`Encode`].
 
-use crate::{Encoder, Header, Length, Result, Tagged, Writer};
+use crate::{Header, Length, Result, SliceWriter, Tagged, Writer};
 
 #[cfg(feature = "alloc")]
 use {alloc::vec::Vec, core::iter};
@@ -23,15 +23,15 @@ pub trait Encode {
     /// Compute the length of this value in bytes when encoded as ASN.1 DER.
     fn encoded_len(&self) -> Result<Length>;
 
-    /// Encode this value as ASN.1 DER using the provided [`Encoder`].
+    /// Encode this value as ASN.1 DER using the provided [`Writer`].
     fn encode(&self, encoder: &mut dyn Writer) -> Result<()>;
 
     /// Encode this value to the provided byte slice, returning a sub-slice
     /// containing the encoded message.
     fn encode_to_slice<'a>(&self, buf: &'a mut [u8]) -> Result<&'a [u8]> {
-        let mut encoder = Encoder::new(buf);
-        self.encode(&mut encoder)?;
-        encoder.finish()
+        let mut writer = SliceWriter::new(buf);
+        self.encode(&mut writer)?;
+        writer.finish()
     }
 
     /// Encode this message as ASN.1 DER, appending it to the provided
@@ -43,7 +43,7 @@ pub trait Encode {
         buf.reserve(expected_len);
         buf.extend(iter::repeat(0).take(expected_len));
 
-        let mut encoder = Encoder::new(buf);
+        let mut encoder = SliceWriter::new(buf);
         self.encode(&mut encoder)?;
         let actual_len = encoder.finish()?.len();
 
@@ -77,7 +77,7 @@ where
         self.value_len().and_then(|len| len.for_tlv())
     }
 
-    /// Encode this value as ASN.1 DER using the provided [`Encoder`].
+    /// Encode this value as ASN.1 DER using the provided [`Writer`].
     fn encode(&self, writer: &mut dyn Writer) -> Result<()> {
         self.header()?.encode(writer)?;
         self.encode_value(writer)
@@ -128,6 +128,6 @@ pub trait EncodeValue {
     fn value_len(&self) -> Result<Length>;
 
     /// Encode value (sans [`Tag`]+[`Length`] header) as ASN.1 DER using the
-    /// provided [`Encoder`].
+    /// provided [`Writer`].
     fn encode_value(&self, encoder: &mut dyn Writer) -> Result<()>;
 }

der/src/length.rs

@@ -1,6 +1,6 @@
 //! Length calculations for encoded ASN.1 DER values
 
-use crate::{Decode, DerOrd, Encode, Encoder, Error, ErrorKind, Reader, Result, Writer};
+use crate::{Decode, DerOrd, Encode, Error, ErrorKind, Reader, Result, SliceWriter, Writer};
 use core::{
     cmp::Ordering,
     fmt,
@@ -270,10 +270,10 @@ impl DerOrd for Length {
         let mut buf1 = [0u8; MAX_DER_OCTETS];
         let mut buf2 = [0u8; MAX_DER_OCTETS];
 
-        let mut encoder1 = Encoder::new(&mut buf1);
+        let mut encoder1 = SliceWriter::new(&mut buf1);
         encoder1.encode(self)?;
 
-        let mut encoder2 = Encoder::new(&mut buf2);
+        let mut encoder2 = SliceWriter::new(&mut buf2);
         encoder2.encode(other)?;
 
         Ok(encoder1.finish()?.cmp(encoder2.finish()?))

der/src/lib.rs

@@ -27,9 +27,9 @@
 
 //! # Usage
 //! ## [`Decode`] and [`Encode`] traits
-//! The [`Decode`] and [`Encode`] traits are the core abstractions on
-//! which this crate is built and control what types can be (de)serialized
-//! as ASN.1 DER.
+//! The [`Decode`] and [`Encode`] traits provide the decoding/encoding API
+//! respectively, and are designed to work in conjunction with concrete ASN.1
+//! types, including all types which impl the [`Sequence`] trait.
 //!
 //! The traits are impl'd for the following Rust core types:
 //! - `()`: ASN.1 `NULL`. See also [`Null`].
@@ -81,11 +81,6 @@
 //! of the [`Encode`] trait, so any type which impls [`Sequence`] can be
 //! used for both decoding and encoding.
 //!
-//! The [`Decoder`] and [`Encoder`] types provide the decoding/encoding API
-//! respectively, and are designed to work in conjunction with concrete ASN.1
-//! types which impl the [`Decode`] and [`Encode`] traits, including
-//! all types which impl the [`Sequence`] trait.
-//!
 //! The following code example shows how to define a struct which maps to the
 //! above schema, as well as impl the [`Sequence`] trait for that struct:
 //!
@@ -97,7 +92,7 @@
 //! // "heapless" usage when the `alloc` feature is disabled.
 //! use der::{
 //!     asn1::{AnyRef, ObjectIdentifier},
-//!     DecodeValue, Decode, Decoder, Encode, Header, Reader, Sequence
+//!     DecodeValue, Decode, SliceReader, Encode, Header, Reader, Sequence
 //! };
 //!
 //! /// X.509 `AlgorithmIdentifier`.
@@ -347,10 +342,8 @@ pub(crate) mod arrayvec;
 mod byte_slice;
 mod datetime;
 mod decode;
-mod decoder;
 mod encode;
 mod encode_ref;
-mod encoder;
 mod error;
 mod header;
 mod length;
@@ -367,17 +360,15 @@ pub use crate::{
     asn1::{AnyRef, Choice, Sequence},
     datetime::DateTime,
     decode::{Decode, DecodeOwned, DecodeValue},
-    decoder::Decoder,
     encode::{Encode, EncodeValue},
     encode_ref::{EncodeRef, EncodeValueRef},
-    encoder::Encoder,
     error::{Error, ErrorKind, Result},
     header::Header,
     length::Length,
     ord::{DerOrd, ValueOrd},
-    reader::Reader,
+    reader::{slice::SliceReader, Reader},
     tag::{Class, FixedTag, Tag, TagMode, TagNumber, Tagged},
-    writer::Writer,
+    writer::{slice::SliceWriter, Writer},
 };
 
 #[cfg(feature = "alloc")]

der/src/reader.rs

@@ -1,9 +1,9 @@
 //! Reader trait.
 
 mod nested;
-
 #[cfg(feature = "pem")]
 pub(crate) mod pem;
+pub(crate) mod slice;
 
 pub(crate) use nested::NestedReader;