Merge pull request #50 from triblespace/codex/identify-next-steps-for-project-advancement

Add VecDeque ByteSource

Author: somethingelseentirely

CHANGELOG.md

@@ -1,6 +1,7 @@
 # Changelog
 
 ## Unreleased
+- added `ByteSource` support for `VecDeque<T>` when `zerocopy` is enabled and kept the deque as owner
 - 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

INVENTORY.md

@@ -5,7 +5,6 @@
 
 ## Desired Functionality
 - Example demonstrating Python + winnow parsing.
-- `ByteSource` implementation for `VecDeque<u8>` to support ring buffers.
-
+ 
 ## Discovered Issues
 - None at the moment.

src/sources.rs

@@ -10,8 +10,8 @@
 //!
 //! | Feature      | Implementations                                                   |
 //! | ------------ | ---------------------------------------------------------------- |
-//! | `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]>` |
+//! | `zerocopy`   | `&'static [T]`, `Box<T>`, `Vec<T>`, `VecDeque<T>` for `T: IntoBytes + Immutable` |
+//! | *(none)*     | `&'static [u8]`, `Box<[u8]>`, `Vec<u8>`, `VecDeque<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`           |
@@ -36,7 +36,7 @@
 //! # let _ = Bytes::from_source(MyData(vec![1, 2, 3]));
 //! ```
 
-use std::borrow::Cow;
+use std::{borrow::Cow, collections::VecDeque};
 use zerocopy::Immutable;
 #[cfg(feature = "zerocopy")]
 use zerocopy::IntoBytes;
@@ -133,6 +133,53 @@ unsafe impl ByteSource for Vec<u8> {
     }
 }
 
+#[cfg(feature = "zerocopy")]
+unsafe impl<T> ByteSource for VecDeque<T>
+where
+    T: IntoBytes + Immutable + Sync + Send + 'static,
+{
+    type Owner = Self;
+
+    fn as_bytes(&self) -> &[u8] {
+        let (front, back) = self.as_slices();
+        assert!(
+            back.is_empty(),
+            "VecDeque is not contiguous; call make_contiguous before creating Bytes",
+        );
+        IntoBytes::as_bytes(front)
+    }
+
+    fn get_owner(self) -> Self::Owner {
+        assert!(
+            self.as_slices().1.is_empty(),
+            "VecDeque is not contiguous; call make_contiguous before creating Bytes",
+        );
+        self
+    }
+}
+
+#[cfg(not(feature = "zerocopy"))]
+unsafe impl ByteSource for VecDeque<u8> {
+    type Owner = Self;
+
+    fn as_bytes(&self) -> &[u8] {
+        let (front, back) = self.as_slices();
+        assert!(
+            back.is_empty(),
+            "VecDeque is not contiguous; call make_contiguous before creating Bytes",
+        );
+        front
+    }
+
+    fn get_owner(self) -> Self::Owner {
+        assert!(
+            self.as_slices().1.is_empty(),
+            "VecDeque is not contiguous; call make_contiguous before creating Bytes",
+        );
+        self
+    }
+}
+
 unsafe impl ByteSource for String {
     type Owner = Self;
 

src/tests.rs

@@ -103,6 +103,57 @@ fn test_slice_to_bytes_unrelated_slice() {
     assert!(bytes.slice_to_bytes(slice).is_none());
 }
 
+#[test]
+fn test_vecdeque_source() {
+    use std::collections::VecDeque;
+
+    let mut deque = VecDeque::new();
+    deque.extend([1u8, 2, 3, 4]);
+    deque.make_contiguous();
+    let bytes = Bytes::from_source(deque);
+    assert_eq!(bytes.as_ref(), &[1, 2, 3, 4]);
+    let owner = bytes
+        .downcast_to_owner::<VecDeque<u8>>()
+        .expect("downcast VecDeque owner");
+    assert_eq!(&*owner, &VecDeque::from([1u8, 2, 3, 4]));
+}
+
+#[cfg(feature = "zerocopy")]
+#[test]
+fn test_vecdeque_generic_source() {
+    use std::collections::VecDeque;
+
+    let mut deque = VecDeque::new();
+    deque.extend([1u16, 2, 3, 4]);
+    deque.make_contiguous();
+    let bytes = Bytes::from_source(deque);
+
+    let mut expected = Vec::new();
+    for n in [1u16, 2, 3, 4] {
+        expected.extend_from_slice(&n.to_ne_bytes());
+    }
+    assert_eq!(bytes.as_ref(), expected.as_slice());
+    let owner = bytes
+        .downcast_to_owner::<VecDeque<u16>>()
+        .expect("downcast VecDeque owner");
+    assert_eq!(&*owner, &VecDeque::from([1u16, 2, 3, 4]));
+}
+
+#[test]
+#[should_panic]
+fn test_vecdeque_noncontiguous_panics() {
+    use std::collections::VecDeque;
+
+    let mut deque: VecDeque<u8> = VecDeque::with_capacity(3);
+    deque.push_back(1);
+    deque.push_back(2);
+    deque.push_back(3);
+    let _ = deque.pop_front();
+    deque.push_back(4); // wraps around
+    assert!(!deque.as_slices().1.is_empty());
+    let _ = Bytes::from_source(deque);
+}
+
 #[test]
 fn test_pop_front() {
     let mut bytes = Bytes::from(b"abc".to_vec());