1 files changed, 36 insertions, 98 deletions

diff --git a/src/algorithm.rs b/src/algorithm.rs
index 5f4b5e8..2a8b6c7 100644
--- a/src/algorithm.rs
+++ b/src/algorithm.rs
@@ -2,14 +2,8 @@
 
 use crate::{Error, Result};
 use core::cmp::Ordering;
-use der::{
-    asn1::{AnyRef, Choice, ObjectIdentifier},
-    Decode, DecodeValue, DerOrd, Encode, EncodeValue, Header, Length, Reader, Sequence, ValueOrd,
-    Writer,
-};
-
-#[cfg(feature = "alloc")]
-use der::asn1::Any;
+use der::asn1::{AnyRef, ObjectIdentifier};
+use der::{Decode, DecodeValue, DerOrd, Encode, Header, Reader, Sequence, ValueOrd};
 
 /// X.509 `AlgorithmIdentifier` as defined in [RFC 5280 Section 4.1.1.2].
 ///
@@ -20,82 +14,17 @@ use der::asn1::Any;
 /// ```
 ///
 /// [RFC 5280 Section 4.1.1.2]: https://tools.ietf.org/html/rfc5280#section-4.1.1.2
-#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
-pub struct AlgorithmIdentifier<Params> {
+pub struct AlgorithmIdentifier<'a> {
     /// Algorithm OID, i.e. the `algorithm` field in the `AlgorithmIdentifier`
     /// ASN.1 schema.
     pub oid: ObjectIdentifier,
 
     /// Algorithm `parameters`.
-    pub parameters: Option<Params>,
-}
-
-impl<'a, Params> DecodeValue<'a> for AlgorithmIdentifier<Params>
-where
-    Params: Choice<'a>,
-{
-    fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> der::Result<Self> {
-        reader.read_nested(header.length, |reader| {
-            Ok(Self {
-                oid: reader.decode()?,
-                parameters: reader.decode()?,
-            })
-        })
-    }
-}
-
-impl<Params> EncodeValue for AlgorithmIdentifier<Params>
-where
-    Params: Encode,
-{
-    fn value_len(&self) -> der::Result<Length> {
-        self.oid.encoded_len()? + self.parameters.encoded_len()?
-    }
-
-    fn encode_value(&self, writer: &mut impl Writer) -> der::Result<()> {
-        self.oid.encode(writer)?;
-        self.parameters.encode(writer)?;
-        Ok(())
-    }
+    pub parameters: Option<AnyRef<'a>>,
 }
 
-impl<'a, Params> Sequence<'a> for AlgorithmIdentifier<Params> where Params: Choice<'a> + Encode {}
-
-impl<'a, Params> TryFrom<&'a [u8]> for AlgorithmIdentifier<Params>
-where
-    Params: Choice<'a> + Encode,
-{
-    type Error = Error;
-
-    fn try_from(bytes: &'a [u8]) -> Result<Self> {
-        Ok(Self::from_der(bytes)?)
-    }
-}
-
-impl<Params> ValueOrd for AlgorithmIdentifier<Params>
-where
-    Params: DerOrd,
-{
-    fn value_cmp(&self, other: &Self) -> der::Result<Ordering> {
-        match self.oid.der_cmp(&other.oid)? {
-            Ordering::Equal => self.parameters.der_cmp(&other.parameters),
-            other => Ok(other),
-        }
-    }
-}
-
-/// `AlgorithmIdentifier` reference which has `AnyRef` parameters.
-pub type AlgorithmIdentifierRef<'a> = AlgorithmIdentifier<AnyRef<'a>>;
-
-/// `AlgorithmIdentifier` with `ObjectIdentifier` parameters.
-pub type AlgorithmIdentifierWithOid = AlgorithmIdentifier<ObjectIdentifier>;
-
-/// `AlgorithmIdentifier` reference which has `Any` parameters.
-#[cfg(feature = "alloc")]
-pub type AlgorithmIdentifierOwned = AlgorithmIdentifier<Any>;
-
-impl<Params> AlgorithmIdentifier<Params> {
+impl<'a> AlgorithmIdentifier<'a> {
     /// Assert the `algorithm` OID is an expected value.
     pub fn assert_algorithm_oid(&self, expected_oid: ObjectIdentifier) -> Result<ObjectIdentifier> {
         if self.oid == expected_oid {
@@ -104,9 +33,7 @@ impl<Params> AlgorithmIdentifier<Params> {
             Err(Error::OidUnknown { oid: expected_oid })
         }
     }
-}
 
-impl<'a> AlgorithmIdentifierRef<'a> {
     /// Assert `parameters` is an OID and has the expected value.
     pub fn assert_parameters_oid(
         &self,
@@ -160,35 +87,46 @@ impl<'a> AlgorithmIdentifierRef<'a> {
                 None => None,
                 Some(p) => match p {
                     AnyRef::NULL => None,
-                    _ => Some(p.decode_as::<ObjectIdentifier>()?),
+                    _ => Some(p.oid()?),
                 },
             },
         ))
     }
 }
 
-#[cfg(feature = "alloc")]
-mod allocating {
-    use super::*;
-    use der::referenced::*;
+impl<'a> DecodeValue<'a> for AlgorithmIdentifier<'a> {
+    fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> der::Result<Self> {
+        reader.read_nested(header.length, |reader| {
+            Ok(Self {
+                oid: reader.decode()?,
+                parameters: reader.decode()?,
+            })
+        })
+    }
+}
 
-    impl<'a> RefToOwned<'a> for AlgorithmIdentifierRef<'a> {
-        type Owned = AlgorithmIdentifierOwned;
-        fn ref_to_owned(&self) -> Self::Owned {
-            AlgorithmIdentifier {
-                oid: self.oid,
-                parameters: self.parameters.ref_to_owned(),
-            }
-        }
+impl<'a> Sequence<'a> for AlgorithmIdentifier<'a> {
+    fn fields<F, T>(&self, f: F) -> der::Result<T>
+    where
+        F: FnOnce(&[&dyn Encode]) -> der::Result<T>,
+    {
+        f(&[&self.oid, &self.parameters])
+    }
+}
+
+impl<'a> TryFrom<&'a [u8]> for AlgorithmIdentifier<'a> {
+    type Error = Error;
+
+    fn try_from(bytes: &'a [u8]) -> Result<Self> {
+        Ok(Self::from_der(bytes)?)
     }
+}
 
-    impl OwnedToRef for AlgorithmIdentifierOwned {
-        type Borrowed<'a> = AlgorithmIdentifierRef<'a>;
-        fn owned_to_ref(&self) -> Self::Borrowed<'_> {
-            AlgorithmIdentifier {
-                oid: self.oid,
-                parameters: self.parameters.owned_to_ref(),
-            }
+impl ValueOrd for AlgorithmIdentifier<'_> {
+    fn value_cmp(&self, other: &Self) -> der::Result<Ordering> {
+        match self.oid.der_cmp(&other.oid)? {
+            Ordering::Equal => self.parameters.der_cmp(&other.parameters),
+            other => Ok(other),
         }
     }
 }