Remove some async traits, use hold info from base rb

async/src/rb.rs

@@ -1,29 +1,28 @@
-use crate::{
-    traits::{AsyncConsumer, AsyncObserver, AsyncProducer, AsyncRingBuffer},
-    wrap::{AsyncCons, AsyncProd},
-};
+use crate::wrap::{AsyncCons, AsyncProd};
 #[cfg(feature = "alloc")]
 use alloc::sync::Arc;
-use core::{
-    mem::MaybeUninit,
-    num::NonZeroUsize,
-    sync::atomic::{AtomicBool, Ordering},
-    task::Waker,
-};
+use core::{mem::MaybeUninit, num::NonZeroUsize};
 use futures::task::AtomicWaker;
 #[cfg(feature = "alloc")]
 use ringbuf::traits::Split;
 use ringbuf::{
+    rb::traits::RbRef,
     storage::Storage,
     traits::{Consumer, Observer, Producer, RingBuffer, SplitRef},
     SharedRb,
 };
 
+pub trait AsyncRbRef: RbRef<Target = AsyncRb<Self::Storage>> {
+    type Storage: Storage;
+}
+impl<S: Storage, R: RbRef<Target = AsyncRb<S>>> AsyncRbRef for R {
+    type Storage = S;
+}
+
 pub struct AsyncRb<S: Storage> {
     base: SharedRb<S>,
-    read: AtomicWaker,
-    write: AtomicWaker,
-    closed: AtomicBool,
+    pub(crate) read: AtomicWaker,
+    pub(crate) write: AtomicWaker,
 }
 
 impl<S: Storage> AsyncRb<S> {
@@ -32,7 +31,6 @@ impl<S: Storage> AsyncRb<S> {
             base,
             read: AtomicWaker::default(),
             write: AtomicWaker::default(),
-            closed: AtomicBool::new(false),
         }
     }
 }
@@ -59,47 +57,42 @@ impl<S: Storage> Observer for AsyncRb<S> {
     unsafe fn unsafe_slices(&self, start: usize, end: usize) -> (&mut [MaybeUninit<S::Item>], &mut [MaybeUninit<S::Item>]) {
         self.base.unsafe_slices(start, end)
     }
+
+    #[inline]
+    fn read_is_held(&self) -> bool {
+        self.base.read_is_held()
+    }
+    #[inline]
+    fn write_is_held(&self) -> bool {
+        self.base.write_is_held()
+    }
 }
 
 impl<S: Storage> Producer for AsyncRb<S> {
     unsafe fn set_write_index(&self, value: usize) {
         self.base.set_write_index(value);
         self.write.wake();
     }
+    fn close(&mut self) {}
 }
 impl<S: Storage> Consumer for AsyncRb<S> {
     unsafe fn set_read_index(&self, value: usize) {
         self.base.set_read_index(value);
         self.read.wake();
     }
+    fn close(&mut self) {}
 }
-impl<S: Storage> RingBuffer for AsyncRb<S> {}
-
-impl<S: Storage> AsyncObserver for AsyncRb<S> {
-    fn is_closed(&self) -> bool {
-        self.closed.load(Ordering::Relaxed)
-    }
-    fn close(&self) {
-        self.closed.store(true, Ordering::Relaxed);
-    }
-}
-impl<S: Storage> AsyncProducer for AsyncRb<S> {
-    fn register_read_waker(&self, waker: &Waker) {
-        self.read.register(waker);
-    }
-}
-impl<S: Storage> AsyncConsumer for AsyncRb<S> {
-    fn register_write_waker(&self, waker: &Waker) {
-        self.write.register(waker);
+impl<S: Storage> RingBuffer for AsyncRb<S> {
+    #[inline]
+    fn hold_read(&self, flag: bool) {
+        self.base.hold_read(flag);
+        self.read.wake()
     }
-}
-impl<S: Storage> AsyncRingBuffer for AsyncRb<S> {
-    fn wake_consumer(&self) {
+    #[inline]
+    fn hold_write(&self, flag: bool) {
+        self.base.hold_write(flag);
         self.write.wake()
     }
-    fn wake_producer(&self) {
-        self.read.wake()
-    }
 }
 
 impl<S: Storage> SplitRef for AsyncRb<S> {

async/src/traits/consumer.rs

@@ -1,22 +1,15 @@
-use super::{AsyncObserver, AsyncRingBuffer};
-use crate::wrap::AsyncCons;
 use core::{
     future::Future,
     pin::Pin,
     task::{Context, Poll, Waker},
 };
-#[cfg(feature = "std")]
-use futures::io::AsyncRead;
-use futures::{future::FusedFuture, Stream};
-use ringbuf::{
-    rb::traits::RbRef,
-    traits::{Consumer, Observer},
-};
+use futures::future::FusedFuture;
+use ringbuf::traits::Consumer;
 #[cfg(feature = "std")]
 use std::io;
 
-pub trait AsyncConsumer: AsyncObserver + Consumer {
-    fn register_write_waker(&self, waker: &Waker);
+pub trait AsyncConsumer: Consumer {
+    fn register_waker(&self, waker: &Waker);
 
     /// Pop item from the ring buffer waiting asynchronously if the buffer is empty.
     ///
@@ -29,7 +22,7 @@ pub trait AsyncConsumer: AsyncObserver + Consumer {
 
     /// Wait for the buffer to contain at least `count` items or to close.
     ///
-    /// Panics if `count` is greater than buffer capacity.
+    /// In debug mode panics if `count` is greater than buffer capacity.
     fn wait_occupied(&mut self, count: usize) -> WaitOccupiedFuture<'_, Self> {
         debug_assert!(count <= self.capacity().get());
         WaitOccupiedFuture {
@@ -54,6 +47,47 @@ pub trait AsyncConsumer: AsyncObserver + Consumer {
             count: 0,
         }
     }
+
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>>
+    where
+        Self: Unpin,
+    {
+        let mut waker_registered = false;
+        loop {
+            let closed = self.is_closed();
+            if let Some(item) = self.try_pop() {
+                break Poll::Ready(Some(item));
+            }
+            if closed {
+                break Poll::Ready(None);
+            }
+            if waker_registered {
+                break Poll::Pending;
+            }
+            self.register_waker(cx.waker());
+            waker_registered = true;
+        }
+    }
+
+    #[cfg(feature = "std")]
+    fn poll_read(mut self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut [u8]) -> Poll<io::Result<usize>>
+    where
+        Self: AsyncConsumer<Item = u8> + Unpin,
+    {
+        let mut waker_registered = false;
+        loop {
+            let closed = self.is_closed();
+            let len = self.pop_slice(buf);
+            if len != 0 || closed {
+                break Poll::Ready(Ok(len));
+            }
+            if waker_registered {
+                break Poll::Pending;
+            }
+            self.register_waker(cx.waker());
+            waker_registered = true;
+        }
+    }
 }
 
 pub struct PopFuture<'a, A: AsyncConsumer> {
@@ -84,7 +118,7 @@ impl<'a, A: AsyncConsumer> Future for PopFuture<'a, A> {
             if waker_registered {
                 break Poll::Pending;
             }
-            self.owner.register_write_waker(cx.waker());
+            self.owner.register_waker(cx.waker());
             waker_registered = true;
         }
     }
@@ -131,7 +165,7 @@ where
             if waker_registered {
                 break Poll::Pending;
             }
-            self.owner.register_write_waker(cx.waker());
+            self.owner.register_waker(cx.waker());
             waker_registered = true;
         }
     }
@@ -162,54 +196,7 @@ impl<'a, A: AsyncConsumer> Future for WaitOccupiedFuture<'a, A> {
             if waker_registered {
                 break Poll::Pending;
             }
-            self.owner.register_write_waker(cx.waker());
-            waker_registered = true;
-        }
-    }
-}
-
-impl<R: RbRef> Stream for AsyncCons<R>
-where
-    R::Target: AsyncRingBuffer,
-{
-    type Item = <R::Target as Observer>::Item;
-
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        let mut waker_registered = false;
-        loop {
-            let closed = self.is_closed();
-            if let Some(item) = self.try_pop() {
-                break Poll::Ready(Some(item));
-            }
-            if closed {
-                break Poll::Ready(None);
-            }
-            if waker_registered {
-                break Poll::Pending;
-            }
-            self.register_write_waker(cx.waker());
-            waker_registered = true;
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-impl<R: RbRef> AsyncRead for AsyncCons<R>
-where
-    R::Target: AsyncRingBuffer<Item = u8>,
-{
-    fn poll_read(mut self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut [u8]) -> Poll<io::Result<usize>> {
-        let mut waker_registered = false;
-        loop {
-            let closed = self.is_closed();
-            let len = self.pop_slice(buf);
-            if len != 0 || closed {
-                break Poll::Ready(Ok(len));
-            }
-            if waker_registered {
-                break Poll::Pending;
-            }
-            self.register_write_waker(cx.waker());
+            self.owner.register_waker(cx.waker());
             waker_registered = true;
         }
     }

async/src/traits/mod.rs

@@ -1,11 +1,7 @@
 pub mod consumer;
-pub mod observer;
 pub mod producer;
-pub mod ring_buffer;
 
 pub use consumer::AsyncConsumer;
-pub use observer::AsyncObserver;
 pub use producer::AsyncProducer;
-pub use ring_buffer::AsyncRingBuffer;
 
 pub use ringbuf::traits::*;