Create HeapRb directly from Vec and Box<[]>

src/rb/macros.rs

@@ -20,12 +20,23 @@ macro_rules! rb_impl_init {
  pub fn try_new(capacity: usize) -> Result<Self, alloc::collections::TryReserveError> {
  let mut vec = alloc::vec::Vec::new();
  vec.try_reserve_exact(capacity)?;
- let ptr = vec.as_mut_ptr();
- core::mem::forget(vec);
- let data = unsafe { Box::from_raw(core::ptr::slice_from_raw_parts_mut(ptr, capacity)) };
- assert_eq!(data.len(), capacity);
- assert_eq!(ptr as *const _, data.as_ptr());
- Ok(unsafe { Self::from_raw_parts(data.into(), usize::default(), usize::default()) })
+ Ok(unsafe { Self::from_raw_parts(vec.into(), usize::default(), usize::default()) })
+ }
+ }
+
+ #[cfg(feature = "alloc")]
+ impl<T> From<alloc::vec::Vec<T>> for $type<crate::storage::Heap<T>> {
+ fn from(value: alloc::vec::Vec<T>) -> Self {
+ let (read, write) = (0, value.len());
+ unsafe { Self::from_raw_parts(crate::utils::vec_to_uninit(value).into(), read, write) }
+ }
+ }
+
+ #[cfg(feature = "alloc")]
+ impl<T> From<alloc::boxed::Box<[T]>> for $type<crate::storage::Heap<T>> {
+ fn from(value: alloc::boxed::Box<[T]>) -> Self {
+ let (read, write) = (0, value.len());
+ unsafe { Self::from_raw_parts(crate::utils::boxed_slice_to_uninit(value).into(), read, write) }
  }
  }
  };

src/storage.rs

@@ -1,8 +1,8 @@
 #[cfg(feature = "alloc")]
 use alloc::{boxed::Box, vec::Vec};
-#[cfg(feature = "alloc")]
-use core::ptr;
 use core::{cell::UnsafeCell, marker::PhantomData, mem::MaybeUninit, ops::Range, ptr::NonNull, slice};
+#[cfg(feature = "alloc")]
+use core::{mem::forget, ptr};
 
 /// Abstract storage for the ring buffer.
 ///
@@ -161,6 +161,15 @@ impl<T> Heap<T> {
  }
 }
 #[cfg(feature = "alloc")]
+impl<T> From<Vec<MaybeUninit<T>>> for Heap<T> {
+ fn from(mut value: Vec<MaybeUninit<T>>) -> Self {
+ let len = value.capacity();
+ let ptr = value.as_mut_ptr();
+ forget(value);
+ Self { ptr, len }
+ }
+}
+#[cfg(feature = "alloc")]
 impl<T> From<Box<[MaybeUninit<T>]>> for Heap<T> {
  fn from(value: Box<[MaybeUninit<T>]>) -> Self {
  Self {

src/tests/init.rs

@@ -0,0 +1,54 @@
+use super::Rb;
+use crate::{storage::Heap, traits::*};
+use alloc::{boxed::Box, vec::Vec};
+
+#[test]
+fn new() {
+ const CAP: usize = 2;
+ let rb = Rb::<Heap<i32>>::new(CAP);
+ let (mut prod, mut cons) = rb.split();
+
+ assert_eq!(prod.capacity().get(), CAP);
+
+ assert_eq!(prod.try_push(0), Ok(()));
+ assert_eq!(prod.try_push(1), Ok(()));
+ assert_eq!(prod.try_push(2), Err(2));
+
+ assert_eq!(cons.try_pop(), Some(0));
+ assert_eq!(cons.try_pop(), Some(1));
+ assert_eq!(cons.try_pop(), None);
+}
+
+#[test]
+fn from_vec() {
+ let mut vec = Vec::with_capacity(2);
+ vec.push(123);
+ let rb = Rb::<Heap<i32>>::from(vec);
+ let (mut prod, mut cons) = rb.split();
+
+ assert_eq!(prod.capacity().get(), 2);
+ assert_eq!(cons.occupied_len(), 1);
+
+ assert_eq!(prod.try_push(321), Ok(()));
+ assert_eq!(prod.try_push(444), Err(444));
+
+ assert_eq!(cons.try_pop(), Some(123));
+ assert_eq!(cons.try_pop(), Some(321));
+ assert_eq!(cons.try_pop(), None);
+}
+
+#[test]
+fn from_boxed_slice() {
+ let boxed_slice = Box::new([123, 321]) as Box<[i32]>;
+ let rb = Rb::<Heap<i32>>::from(boxed_slice);
+ let (mut prod, mut cons) = rb.split();
+
+ assert_eq!(prod.capacity().get(), 2);
+ assert_eq!(cons.occupied_len(), 2);
+
+ assert_eq!(prod.try_push(444), Err(444));
+
+ assert_eq!(cons.try_pop(), Some(123));
+ assert_eq!(cons.try_pop(), Some(321));
+ assert_eq!(cons.try_pop(), None);
+}

src/tests/mod.rs

@@ -10,6 +10,8 @@ mod drop;
 mod fmt_write;
 mod frozen;
 mod hold;
+#[cfg(feature = "alloc")]
+mod init;
 mod iter;
 mod overwrite;
 #[cfg(feature = "std")]

src/utils.rs

@@ -1,3 +1,5 @@
+#[cfg(feature = "alloc")]
+use alloc::{boxed::Box, vec::Vec};
 use core::mem::{self, MaybeUninit};
 
 // TODO: Remove on `maybe_uninit_uninit_array` stabilization.
@@ -26,3 +28,17 @@ pub unsafe fn write_uninit_slice<'a, T: Copy>(dst: &'a mut [T], src: &[MaybeUnin
  dst.copy_from_slice(slice_assume_init_ref(src));
  dst
 }
+
+#[cfg(feature = "alloc")]
+pub fn vec_to_uninit<T>(value: Vec<T>) -> Vec<MaybeUninit<T>> {
+ let value = mem::ManuallyDrop::new(value);
+ let ptr = &value as *const _ as *const Vec<MaybeUninit<T>>;
+ unsafe { ptr.read() }
+}
+
+#[cfg(feature = "alloc")]
+pub fn boxed_slice_to_uninit<T>(value: Box<[T]>) -> Box<[MaybeUninit<T>]> {
+ let value = mem::ManuallyDrop::new(value);
+ let ptr = &value as *const _ as *const Box<[MaybeUninit<T>]>;
+ unsafe { ptr.read() }
+}