Switch from std to alloc (#9)

* Switch from std to alloc

* Add back `std` feature flag, and fix small error in test configure gate

* Fix no_std gating in lib.rs, and use `std` feature instead of `alloc` for docs.rs

---------

Co-authored-by: Maximilien Cura <70043540+max-cura@users.noreply.github.com>

Author: all-is-to-be-dared

Cargo.toml

@@ -49,7 +49,10 @@ critical-section = [
 disable-cache-padding = [
     "maitake-sync?/no-cache-pad",
 ]
-std = []
+alloc = []
+std = [
+    "alloc"
+]
 maitake-sync-0_2 = [
     "dep:maitake-sync",
 ]

src/lib.rs

@@ -4,6 +4,9 @@
 
 #![cfg_attr(not(any(test, feature = "std")), no_std)]
 
+#[cfg(feature = "alloc")]
+extern crate alloc;
+
 /// Type aliases for different generic configurations
 ///
 pub mod nicknames;
@@ -26,7 +29,7 @@ pub mod export {
     pub use const_init::ConstInit;
 }
 
-#[cfg(all(test, feature = "std"))]
+#[cfg(all(test, feature = "alloc"))]
 mod test {
     use core::{ops::Deref, time::Duration};
 
@@ -39,7 +42,7 @@ mod test {
         },
     };
 
-    #[cfg(all(target_has_atomic = "ptr", feature = "std"))]
+    #[cfg(all(target_has_atomic = "ptr", feature = "alloc"))]
     #[test]
     fn ux() {
         use crate::traits::{notifier::blocking::Blocking, storage::BoxedSlice};

src/nicknames.rs

@@ -21,13 +21,13 @@
 
 #![allow(unused_imports)]
 
-#[cfg(feature = "std")]
+#[cfg(feature = "alloc")]
 use crate::queue::ArcBBQueue;
 #[cfg(target_has_atomic = "ptr")]
 use crate::traits::coordination::cas::AtomicCoord;
 #[cfg(feature = "critical-section")]
 use crate::traits::coordination::cs::CsCoord;
-#[cfg(feature = "std")]
+#[cfg(feature = "alloc")]
 use crate::traits::storage::BoxedSlice;
 use crate::{
     queue::BBQueue,
@@ -51,49 +51,49 @@ pub type Churrasco<const N: usize> = BBQueue<Inline<N>, AtomicCoord, Blocking>;
 pub type Texas<const N: usize, A> = BBQueue<Inline<N>, AtomicCoord, A>;
 
 /// Heap Buffer, Critical Section, Blocking, Borrowed
-#[cfg(all(feature = "std", feature = "critical-section"))]
+#[cfg(all(feature = "alloc", feature = "critical-section"))]
 pub type Braai = BBQueue<BoxedSlice, CsCoord, Blocking>;
 
 /// Heap Buffer, Critical Section, Async, Borrowed
-#[cfg(all(feature = "std", feature = "critical-section"))]
+#[cfg(all(feature = "alloc", feature = "critical-section"))]
 pub type SiuMei<A> = BBQueue<BoxedSlice, CsCoord, A>;
 
 /// Heap Buffer, Atomics, Blocking, Borrowed
-#[cfg(all(feature = "std", target_has_atomic = "ptr"))]
+#[cfg(all(feature = "alloc", target_has_atomic = "ptr"))]
 pub type YakiNiku = BBQueue<BoxedSlice, AtomicCoord, Blocking>;
 
 /// Heap Buffer, Atomics, Async, Borrowed
-#[cfg(all(feature = "std", target_has_atomic = "ptr"))]
+#[cfg(all(feature = "alloc", target_has_atomic = "ptr"))]
 pub type Tandoori<A> = BBQueue<BoxedSlice, AtomicCoord, A>;
 
 /// Inline Storage, Critical Section, Blocking, Arc
-#[cfg(all(feature = "std", feature = "critical-section"))]
+#[cfg(all(feature = "alloc", feature = "critical-section"))]
 pub type Asado<const N: usize> = ArcBBQueue<Inline<N>, CsCoord, Blocking>;
 
 /// Inline Storage, Critical Section, Async, Arc
-#[cfg(all(feature = "std", feature = "critical-section"))]
+#[cfg(all(feature = "alloc", feature = "critical-section"))]
 pub type Carolina<const N: usize, A> = ArcBBQueue<Inline<N>, CsCoord, A>;
 
 /// Inline Storage, Atomics, Blocking, Arc
-#[cfg(all(feature = "std", target_has_atomic = "ptr"))]
+#[cfg(all(feature = "alloc", target_has_atomic = "ptr"))]
 pub type Barbacoa<const N: usize> = ArcBBQueue<Inline<N>, AtomicCoord, Blocking>;
 
 /// Inline Storage, Atomics, Async, Arc
-#[cfg(all(feature = "std", target_has_atomic = "ptr"))]
+#[cfg(all(feature = "alloc", target_has_atomic = "ptr"))]
 pub type KansasCity<const N: usize, A> = ArcBBQueue<Inline<N>, AtomicCoord, A>;
 
 /// Heap Buffer, Critical Section, Blocking, Arc
-#[cfg(all(feature = "std", feature = "critical-section"))]
+#[cfg(all(feature = "alloc", feature = "critical-section"))]
 pub type Kebab = ArcBBQueue<BoxedSlice, CsCoord, Blocking>;
 
 /// Heap Buffer, Critical Section, Async, Arc
-#[cfg(all(feature = "std", feature = "critical-section"))]
+#[cfg(all(feature = "alloc", feature = "critical-section"))]
 pub type Satay<A> = ArcBBQueue<BoxedSlice, CsCoord, A>;
 
 /// Heap Buffer, Atomics, Blocking, Arc
-#[cfg(all(feature = "std", target_has_atomic = "ptr"))]
+#[cfg(all(feature = "alloc", target_has_atomic = "ptr"))]
 pub type GogiGui = ArcBBQueue<BoxedSlice, AtomicCoord, Blocking>;
 
 /// Heap Buffer, Atomics, Async, Arc
-#[cfg(all(feature = "std", target_has_atomic = "ptr"))]
+#[cfg(all(feature = "alloc", target_has_atomic = "ptr"))]
 pub type Lechon<A> = ArcBBQueue<BoxedSlice, AtomicCoord, A>;

src/queue.rs

@@ -12,7 +12,7 @@ use crate::{
     },
 };
 
-#[cfg(feature = "std")]
+#[cfg(feature = "alloc")]
 use crate::traits::bbqhdl::BbqHandle;
 
 /// A standard bbqueue
@@ -33,13 +33,13 @@ impl<S: Storage, C: Coord, N: Notifier> BBQueue<S, C, N> {
 }
 
 /// A BBQueue wrapped in an Arc
-#[cfg(feature = "std")]
-pub struct ArcBBQueue<S, C, N>(pub(crate) std::sync::Arc<BBQueue<S, C, N>>);
+#[cfg(feature = "alloc")]
+pub struct ArcBBQueue<S, C, N>(pub(crate) alloc::sync::Arc<BBQueue<S, C, N>>);
 
-#[cfg(feature = "std")]
+#[cfg(feature = "alloc")]
 impl<S: Storage, C: Coord, N: Notifier> ArcBBQueue<S, C, N> {
     pub fn new_with_storage(sto: S) -> Self {
-        Self(std::sync::Arc::new(BBQueue::new_with_storage(sto)))
+        Self(alloc::sync::Arc::new(BBQueue::new_with_storage(sto)))
     }
 }
 
@@ -78,29 +78,29 @@ impl<S: Storage, C: Coord, N: Notifier> BBQueue<S, C, N> {
     }
 }
 
-#[cfg(feature = "std")]
+#[cfg(feature = "alloc")]
 impl<S: Storage, C: Coord, N: Notifier> crate::queue::ArcBBQueue<S, C, N> {
-    pub fn framed_producer(&self) -> FramedProducer<std::sync::Arc<BBQueue<S, C, N>>> {
+    pub fn framed_producer(&self) -> FramedProducer<alloc::sync::Arc<BBQueue<S, C, N>>> {
         FramedProducer {
             bbq: self.0.bbq_ref(),
             pd: PhantomData,
         }
     }
 
-    pub fn framed_consumer(&self) -> FramedConsumer<std::sync::Arc<BBQueue<S, C, N>>> {
+    pub fn framed_consumer(&self) -> FramedConsumer<alloc::sync::Arc<BBQueue<S, C, N>>> {
         FramedConsumer {
             bbq: self.0.bbq_ref(),
             pd: PhantomData,
         }
     }
 
-    pub fn stream_producer(&self) -> StreamProducer<std::sync::Arc<BBQueue<S, C, N>>> {
+    pub fn stream_producer(&self) -> StreamProducer<alloc::sync::Arc<BBQueue<S, C, N>>> {
         StreamProducer {
             bbq: self.0.bbq_ref(),
         }
     }
 
-    pub fn stream_consumer(&self) -> StreamConsumer<std::sync::Arc<BBQueue<S, C, N>>> {
+    pub fn stream_consumer(&self) -> StreamConsumer<alloc::sync::Arc<BBQueue<S, C, N>>> {
         StreamConsumer {
             bbq: self.0.bbq_ref(),
         }

src/traits/bbqhdl.rs

@@ -80,8 +80,8 @@ impl<S: Storage, C: Coord, N: Notifier> BbqHandle for &'_ BBQueue<S, C, N> {
     }
 }
 
-#[cfg(feature = "std")]
-impl<S: Storage, C: Coord, N: Notifier> BbqHandle for std::sync::Arc<BBQueue<S, C, N>> {
+#[cfg(feature = "alloc")]
+impl<S: Storage, C: Coord, N: Notifier> BbqHandle for alloc::sync::Arc<BBQueue<S, C, N>> {
     type Target = Self;
     type Storage = S;
     type Coord = C;

src/traits/storage.rs

@@ -13,6 +13,9 @@
 use const_init::ConstInit;
 use core::{cell::UnsafeCell, mem::MaybeUninit, ptr::NonNull};
 
+#[cfg(feature = "alloc")]
+use alloc::{boxed::Box, vec::Vec};
+
 /// Trait for providing access to the storage
 ///
 /// Must always return the same ptr/len forever.
@@ -80,15 +83,15 @@ impl<const N: usize> Storage for &'_ Inline<N> {
 }
 
 /// Boxed/heap-ful storage
-#[cfg(feature = "std")]
+#[cfg(feature = "alloc")]
 pub struct BoxedSlice {
     buf: Box<[UnsafeCell<MaybeUninit<u8>>]>,
 }
 
-#[cfg(feature = "std")]
+#[cfg(feature = "alloc")]
 unsafe impl Sync for BoxedSlice {}
 
-#[cfg(feature = "std")]
+#[cfg(feature = "alloc")]
 impl BoxedSlice {
     /// Create a new BoxedSlice with capacity `len`.
     pub fn new(len: usize) -> Self {
@@ -108,7 +111,7 @@ impl BoxedSlice {
     }
 }
 
-#[cfg(feature = "std")]
+#[cfg(feature = "alloc")]
 impl Storage for BoxedSlice {
     fn ptr_len(&self) -> (NonNull<u8>, usize) {
         let len = self.buf.len();