der: impl DecodeValue/EncodeValue/Tagged for Cow

Also includes a POC that the traits work with `OctetStringRef`

Author: tarcieri

der/src/asn1/octet_string.rs

@@ -73,6 +73,16 @@ impl<'a> DecodeValue<'a> for &'a OctetStringRef {
     }
 }
 
+impl EncodeValue for OctetStringRef {
+    fn value_len(&self) -> Result<Length, Error> {
+        self.inner.value_len()
+    }
+
+    fn encode_value(&self, writer: &mut impl Writer) -> Result<(), Error> {
+        self.inner.encode_value(writer)
+    }
+}
+
 impl EncodeValue for &OctetStringRef {
     fn value_len(&self) -> Result<Length, Error> {
         self.inner.value_len()
@@ -383,6 +393,9 @@ mod tests {
     };
     use hex_literal::hex;
 
+    #[cfg(feature = "alloc")]
+    use alloc::borrow::Cow;
+
     #[test]
     fn octet_string_decode() {
         // PrintableString "hi"
@@ -405,6 +418,23 @@ mod tests {
         assert_eq!(AsRef::<str>::as_ref(&res), "hi");
     }
 
+    #[cfg(feature = "alloc")]
+    #[test]
+    fn cow_octet_string_decode_and_encode() {
+        // PrintableString "hi"
+        const EXAMPLE: &[u8] = &hex!(
+            "040c" // primitive definite length OCTET STRING
+            "48656c6c6f2c20776f726c64" // "Hello, world"
+        );
+
+        let decoded = Cow::<OctetStringRef>::from_der(EXAMPLE).unwrap();
+        assert_eq!(decoded.as_bytes(), b"Hello, world");
+
+        use crate::Encode;
+        let encoded = decoded.to_der().unwrap();
+        assert_eq!(EXAMPLE, encoded);
+    }
+
     #[test]
     #[cfg(all(feature = "alloc", feature = "ber"))]
     fn decode_ber_primitive_definite() {

der/src/decode.rs

@@ -11,7 +11,10 @@ use crate::{PemReader, pem::PemLabel};
 use crate::{ErrorKind, Length, Tag};
 
 #[cfg(feature = "alloc")]
-use alloc::boxed::Box;
+use alloc::{
+    borrow::{Cow, ToOwned},
+    boxed::Box,
+};
 
 #[cfg(feature = "ber")]
 use crate::EncodingRules;
@@ -207,3 +210,16 @@ where
         Ok(Box::new(T::decode_value(reader, header)?))
     }
 }
+
+#[cfg(feature = "alloc")]
+impl<'a, T> DecodeValue<'a> for Cow<'a, T>
+where
+    T: ToOwned + ?Sized,
+    &'a T: DecodeValue<'a>,
+{
+    type Error = <&'a T as DecodeValue<'a>>::Error;
+
+    fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self, Self::Error> {
+        Ok(Cow::Borrowed(<&'a T>::decode_value(reader, header)?))
+    }
+}

der/src/encode.rs

@@ -4,7 +4,11 @@ use crate::{Header, Length, Result, SliceWriter, Tagged, Writer};
 use core::marker::PhantomData;
 
 #[cfg(feature = "alloc")]
-use {alloc::boxed::Box, alloc::vec::Vec};
+use alloc::{
+    borrow::{Cow, ToOwned},
+    boxed::Box,
+    vec::Vec,
+};
 
 #[cfg(feature = "pem")]
 use {
@@ -228,6 +232,20 @@ where
     }
 }
 
+#[cfg(feature = "alloc")]
+impl<T> EncodeValue for Cow<'_, T>
+where
+    T: EncodeValue + ToOwned + ?Sized,
+{
+    fn value_len(&self) -> Result<Length> {
+        self.as_ref().value_len()
+    }
+
+    fn encode_value(&self, writer: &mut impl Writer) -> Result<()> {
+        self.as_ref().encode_value(writer)
+    }
+}
+
 /// Encodes value only (without tag + length) to a slice.
 pub(crate) fn encode_value_to_slice<'a, T>(buf: &'a mut [u8], value: &T) -> Result<&'a [u8]>
 where

der/src/tag.rs

@@ -10,6 +10,9 @@ pub use self::{class::Class, mode::TagMode, number::TagNumber};
 use crate::{Decode, DerOrd, Encode, Error, ErrorKind, Length, Reader, Result, Writer};
 use core::{cmp::Ordering, fmt};
 
+#[cfg(feature = "alloc")]
+use alloc::borrow::{Cow, ToOwned};
+
 /// Indicator bit for constructed form encoding (i.e. vs primitive form)
 const CONSTRUCTED_FLAG: u8 = 0b100000;
 
@@ -30,6 +33,15 @@ pub trait FixedTag {
     const TAG: Tag;
 }
 
+#[cfg(feature = "alloc")]
+impl<'a, T> FixedTag for Cow<'a, T>
+where
+    T: ToOwned + ?Sized,
+    &'a T: FixedTag,
+{
+    const TAG: Tag = <&'a T>::TAG;
+}
+
 /// Types which have an ASN.1 [`Tag`].
 ///
 /// ## Example