Generalize Cow ByteSource

Author: somethingelseentirely

CHANGELOG.md

@@ -1,6 +1,7 @@
 # Changelog
 
 ## Unreleased
+- added `ByteSource` support for `Cow<'static, T>` where `T: AsRef<[u8]>`
 - added `ByteArea` for staged file writes with `Section::freeze()` to return `Bytes`
 - `SectionWriter::reserve` now accepts a zerocopy type instead of an alignment constant
 - `ByteArea` reuses previous pages so allocations align only to the element type

INVENTORY.md

@@ -6,6 +6,7 @@
 ## Desired Functionality
 - Example demonstrating Python + winnow parsing.
 - Additional Kani proofs covering `try_unwrap_owner` and weak references.
+- `ByteSource` implementation for `VecDeque<u8>` to support ring buffers.
 
 ## Discovered Issues
 - Missing tests for `pop_front` and `pop_back` helpers.

src/sources.rs

@@ -10,8 +10,8 @@
 //!
 //! | Feature      | Implementations                                                   |
 //! | ------------ | ---------------------------------------------------------------- |
-//! | `zerocopy`   | `&'static [T]`, `Box<T>` and `Vec<T>` for `T: IntoBytes + Immutable` |
-//! | *(none)*     | `&'static [u8]`, `Box<[u8]>`, `Vec<u8>`, `String`, `&'static str` |
+//! | `zerocopy`   | `&'static [T]`, `Box<T>`, `Vec<T>` for `T: IntoBytes + Immutable` |
+//! | *(none)*     | `&'static [u8]`, `Box<[u8]>`, `Vec<u8>`, `String`, `&'static str`, `Cow<'static, T>` for `T: AsRef<[u8]>` |
 //! | `bytes`      | `bytes::Bytes`                                                   |
 //! | `ownedbytes` | `ownedbytes::OwnedBytes`                                         |
 //! | `mmap`       | `memmap2::Mmap` and `ByteOwner` for `memmap2::MmapRaw`           |
@@ -145,41 +145,27 @@ unsafe impl ByteSource for String {
     }
 }
 
-#[cfg(feature = "zerocopy")]
-unsafe impl<T> ByteSource for Cow<'static, [T]>
-where
-    T: IntoBytes + Immutable + Sync + Send + Clone + 'static,
-{
-    type Owner = Self;
-
-    fn as_bytes(&self) -> &[u8] {
-        let slice: &[T] = self.as_ref();
-        IntoBytes::as_bytes(slice)
-    }
-
-    fn get_owner(self) -> Self::Owner {
-        self
-    }
-}
-
-#[cfg(not(feature = "zerocopy"))]
-unsafe impl ByteSource for Cow<'static, [u8]> {
+unsafe impl ByteSource for &'static str {
     type Owner = Self;
 
     fn as_bytes(&self) -> &[u8] {
-        self.as_ref()
+        (*self).as_bytes()
     }
 
     fn get_owner(self) -> Self::Owner {
         self
     }
 }
 
-unsafe impl ByteSource for &'static str {
+unsafe impl<T> ByteSource for Cow<'static, T>
+where
+    T: ?Sized + ToOwned + AsRef<[u8]> + Sync + Send + 'static,
+    T::Owned: Sync + Send + 'static,
+{
     type Owner = Self;
 
     fn as_bytes(&self) -> &[u8] {
-        (*self).as_bytes()
+        self.as_ref().as_ref()
     }
 
     fn get_owner(self) -> Self::Owner {

src/tests.rs

@@ -276,31 +276,22 @@ fn test_cow_u8_borrowed_source() {
     assert_eq!(bytes_borrowed.as_ref(), borrowed.as_ref());
 }
 
-#[cfg(feature = "zerocopy")]
 #[test]
-fn test_cow_zerocopy_owned_source() {
+fn test_cow_str_owned_source() {
     use std::borrow::Cow;
 
-    let owned: Cow<'static, [u32]> = Cow::Owned(vec![1, 2, 3, 4]);
+    let owned: Cow<'static, str> = Cow::Owned(String::from("abcd"));
     let bytes_owned = Bytes::from_source(owned.clone());
-    assert_eq!(
-        bytes_owned.as_ref(),
-        zerocopy::IntoBytes::as_bytes(owned.as_ref())
-    );
+    assert_eq!(bytes_owned.as_ref(), owned.as_bytes());
 }
 
-#[cfg(feature = "zerocopy")]
 #[test]
-fn test_cow_zerocopy_borrowed_source() {
+fn test_cow_str_borrowed_source() {
     use std::borrow::Cow;
 
-    static BORROWED: [u32; 2] = [5, 6];
-    let borrowed: Cow<'static, [u32]> = Cow::Borrowed(&BORROWED);
+    let borrowed: Cow<'static, str> = Cow::Borrowed("abcd");
     let bytes_borrowed = Bytes::from_source(borrowed.clone());
-    assert_eq!(
-        bytes_borrowed.as_ref(),
-        zerocopy::IntoBytes::as_bytes(borrowed.as_ref())
-    );
+    assert_eq!(bytes_borrowed.as_ref(), borrowed.as_bytes());
 }
 
 #[cfg(all(feature = "mmap", feature = "zerocopy"))]