Make handle methods const (#7)

* Make some methods const

* Add test, fmt

Author: jamesmunns

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "bbq2"
-version = "0.4.1"
+version = "0.4.2"
 description = "A SPSC, lockless, no_std, thread safe, queue, based on BipBuffers"
 repository = "https://github.com/jamesmunns/bbq2"
 authors = ["James Munns <james@onevariable.com>"]

Cargo.toml

@@ -1,8 +1,19 @@
 use core::marker::PhantomData;
 
-use crate::{prod_cons::{framed::{FramedConsumer, FramedProducer}, stream::{StreamConsumer, StreamProducer}}, traits::{
-    bbqhdl::BbqHandle, coordination::Coord, notifier::Notifier, storage::{ConstStorage, Storage}
-}};
+use crate::{
+    prod_cons::{
+        framed::{FramedConsumer, FramedProducer},
+        stream::{StreamConsumer, StreamProducer},
+    },
+    traits::{
+        coordination::Coord,
+        notifier::Notifier,
+        storage::{ConstStorage, Storage},
+    },
+};
+
+#[cfg(feature = "std")]
+use crate::traits::bbqhdl::BbqHandle;
 
 /// A standard bbqueue
 pub struct BBQueue<S, C, N> {
@@ -43,32 +54,27 @@ impl<S: ConstStorage, C: Coord, N: Notifier> BBQueue<S, C, N> {
     }
 }
 
-
 impl<S: Storage, C: Coord, N: Notifier> BBQueue<S, C, N> {
-    pub fn framed_producer(&self) -> FramedProducer<&'_ Self> {
+    pub const fn framed_producer(&self) -> FramedProducer<&'_ Self> {
         FramedProducer {
-            bbq: self.bbq_ref(),
+            bbq: self,
             pd: PhantomData,
         }
     }
 
-    pub fn framed_consumer(&self) -> FramedConsumer<&'_ Self> {
+    pub const fn framed_consumer(&self) -> FramedConsumer<&'_ Self> {
         FramedConsumer {
-            bbq: self.bbq_ref(),
+            bbq: self,
             pd: PhantomData,
         }
     }
 
-    pub fn stream_producer(&self) -> StreamProducer<&'_ Self> {
-        StreamProducer {
-            bbq: self.bbq_ref(),
-        }
+    pub const fn stream_producer(&self) -> StreamProducer<&'_ Self> {
+        StreamProducer { bbq: self }
     }
 
-    pub fn stream_consumer(&self) -> StreamConsumer<&'_ Self> {
-        StreamConsumer {
-            bbq: self.bbq_ref(),
-        }
+    pub const fn stream_consumer(&self) -> StreamConsumer<&'_ Self> {
+        StreamConsumer { bbq: self }
     }
 }
 
@@ -100,3 +106,31 @@ impl<S: Storage, C: Coord, N: Notifier> crate::queue::ArcBBQueue<S, C, N> {
         }
     }
 }
+
+#[cfg(test)]
+mod test {
+    use crate::traits::{
+        coordination::cas::AtomicCoord, notifier::blocking::Blocking, storage::Inline,
+    };
+
+    use super::*;
+
+    type Queue = BBQueue<Inline<4096>, AtomicCoord, Blocking>;
+    static QUEUE: Queue = BBQueue::new();
+    static PRODUCER: FramedProducer<&'static Queue, u16> = QUEUE.framed_producer();
+    static CONSUMER: FramedConsumer<&'static Queue, u16> = QUEUE.framed_consumer();
+
+    #[test]
+    fn handles() {
+        let mut wgr = PRODUCER.grant(16).unwrap();
+        wgr.iter_mut().for_each(|w| *w = 123);
+        wgr.commit(16);
+
+        let rgr = CONSUMER.read().unwrap();
+        assert_eq!(rgr.len(), 16);
+        for b in rgr.iter() {
+            assert_eq!(*b, 123);
+        }
+        rgr.release();
+    }
+}

src/queue.rs

@@ -17,7 +17,13 @@
 
 use core::{marker::PhantomData, ops::Deref};
 
-use crate::{prod_cons::{framed::{FramedConsumer, FramedProducer, LenHeader}, stream::{StreamConsumer, StreamProducer}}, queue::BBQueue};
+use crate::{
+    prod_cons::{
+        framed::{FramedConsumer, FramedProducer, LenHeader},
+        stream::{StreamConsumer, StreamProducer},
+    },
+    queue::BBQueue,
+};
 
 use super::{coordination::Coord, notifier::Notifier, storage::Storage};
 

src/traits/bbqhdl.rs

@@ -65,7 +65,11 @@ unsafe impl Coord for AtomicCoord {
         self.last.store(0, Ordering::Release);
     }
 
-    fn grant_max_remaining(&self, capacity: usize, mut sz: usize) -> Result<(usize, usize), WriteGrantError> {
+    fn grant_max_remaining(
+        &self,
+        capacity: usize,
+        mut sz: usize,
+    ) -> Result<(usize, usize), WriteGrantError> {
         if self.write_in_progress.swap(true, Ordering::AcqRel) {
             return Err(WriteGrantError::GrantInProgress);
         }

src/traits/coordination/cas.rs

@@ -71,7 +71,11 @@ unsafe impl Coord for CsCoord {
         self.last.store(0, Ordering::Release);
     }
 
-    fn grant_max_remaining(&self, capacity: usize, mut sz: usize) -> Result<(usize, usize), WriteGrantError> {
+    fn grant_max_remaining(
+        &self,
+        capacity: usize,
+        mut sz: usize,
+    ) -> Result<(usize, usize), WriteGrantError> {
         critical_section::with(|_cs| {
             if self.write_in_progress.load(Ordering::Relaxed) {
                 return Err(WriteGrantError::GrantInProgress);

src/traits/coordination/cs.rs

@@ -54,7 +54,11 @@ pub unsafe trait Coord {
 
     // Write Grants
 
-    fn grant_max_remaining(&self, capacity: usize, sz: usize) -> Result<(usize, usize), WriteGrantError>;
+    fn grant_max_remaining(
+        &self,
+        capacity: usize,
+        sz: usize,
+    ) -> Result<(usize, usize), WriteGrantError>;
     fn grant_exact(&self, capacity: usize, sz: usize) -> Result<usize, WriteGrantError>;
     fn commit_inner(&self, capacity: usize, grant_len: usize, used: usize);