Atomically replace hold flag

async/src/rb.rs

@@ -82,14 +82,16 @@ impl<S: Storage> Consumer for AsyncRb<S> {
 }
 impl<S: Storage> RingBuffer for AsyncRb<S> {
  #[inline]
- unsafe fn hold_read(&self, flag: bool) {
- self.base.hold_read(flag);
- self.read.wake()
+ unsafe fn hold_read(&self, flag: bool) -> bool {
+ let old = self.base.hold_read(flag);
+ self.read.wake();
+ old
  }
  #[inline]
- unsafe fn hold_write(&self, flag: bool) {
- self.base.hold_write(flag);
- self.write.wake()
+ unsafe fn hold_write(&self, flag: bool) -> bool {
+ let old = self.base.hold_write(flag);
+ self.write.wake();
+ old
  }
 }
 

blocking/src/rb.rs

@@ -79,13 +79,15 @@ impl<S: Storage, X: Semaphore> Consumer for BlockingRb<S, X> {
  }
 }
 impl<S: Storage, X: Semaphore> RingBuffer for BlockingRb<S, X> {
- unsafe fn hold_read(&self, flag: bool) {
- self.base.hold_read(flag);
+ unsafe fn hold_read(&self, flag: bool) -> bool {
+ let old = self.base.hold_read(flag);
  self.read.give();
+ old
  }
- unsafe fn hold_write(&self, flag: bool) {
- self.base.hold_write(flag);
+ unsafe fn hold_write(&self, flag: bool) -> bool {
+ let old = self.base.hold_write(flag);
  self.write.give();
+ old
  }
 }
 

src/rb/local.rs

@@ -115,12 +115,12 @@ impl<S: Storage> Consumer for LocalRb<S> {
 
 impl<S: Storage> RingBuffer for LocalRb<S> {
  #[inline]
- unsafe fn hold_read(&self, flag: bool) {
- self.read.held.set(flag)
+ unsafe fn hold_read(&self, flag: bool) -> bool {
+ self.read.held.replace(flag)
  }
  #[inline]
- unsafe fn hold_write(&self, flag: bool) {
- self.write.held.set(flag)
+ unsafe fn hold_write(&self, flag: bool) -> bool {
+ self.write.held.replace(flag)
  }
 }
 

src/rb/shared.rs

@@ -127,12 +127,12 @@ impl<S: Storage> Consumer for SharedRb<S> {
 
 impl<S: Storage> RingBuffer for SharedRb<S> {
  #[inline]
- unsafe fn hold_read(&self, flag: bool) {
- self.read_held.store(flag, Ordering::Relaxed)
+ unsafe fn hold_read(&self, flag: bool) -> bool {
+ self.read_held.swap(flag, Ordering::Relaxed)
  }
  #[inline]
- unsafe fn hold_write(&self, flag: bool) {
- self.write_held.store(flag, Ordering::Relaxed)
+ unsafe fn hold_write(&self, flag: bool) -> bool {
+ self.write_held.swap(flag, Ordering::Relaxed)
  }
 }
 

src/traits/ring_buffer.rs

@@ -19,16 +19,20 @@ use super::{
 pub trait RingBuffer: Observer + Consumer + Producer {
  /// Tell whether read end of the ring buffer is held by consumer or not.
  ///
+ /// Returns old value.
+ ///
  /// # Safety
  ///
  /// Must not be set to `false` while consumer exists.
- unsafe fn hold_read(&self, flag: bool);
+ unsafe fn hold_read(&self, flag: bool) -> bool;
  /// Tell whether write end of the ring buffer is held by producer or not.
  ///
+ /// Returns old value.
+ ///
  /// # Safety
  ///
  /// Must not be set to `false` while producer exists.
- unsafe fn hold_write(&self, flag: bool);
+ unsafe fn hold_write(&self, flag: bool) -> bool;
 
  /// Pushes an item to the ring buffer overwriting the latest item if the buffer is full.
  ///
@@ -78,11 +82,11 @@ impl<D: DelegateRingBuffer> RingBuffer for D
 where
  D::Base: RingBuffer,
 {
- unsafe fn hold_read(&self, flag: bool) {
- self.base().hold_read(flag);
+ unsafe fn hold_read(&self, flag: bool) -> bool {
+ self.base().hold_read(flag)
  }
- unsafe fn hold_write(&self, flag: bool) {
- self.base().hold_write(flag);
+ unsafe fn hold_write(&self, flag: bool) -> bool {
+ self.base().hold_write(flag)
  }
 
  #[inline]

src/wrap/direct.rs

@@ -41,12 +41,10 @@ impl<R: RbRef, const P: bool, const C: bool> Direct<R, P, C> {
  /// There must be no more than one wrapper with the same parameter being `true`.
  pub fn new(rb: R) -> Self {
  if P {
- assert!(!rb.rb().write_is_held());
- unsafe { rb.rb().hold_write(true) };
+ assert!(!unsafe { rb.rb().hold_write(true) });
  }
  if C {
- assert!(!rb.rb().read_is_held());
- unsafe { rb.rb().hold_read(true) };
+ assert!(!unsafe { rb.rb().hold_read(true) });
  }
  Self { rb }
  }

src/wrap/frozen.rs

@@ -41,12 +41,10 @@ impl<R: RbRef, const P: bool, const C: bool> Frozen<R, P, C> {
  /// Create new ring buffer cache.
  pub fn new(rb: R) -> Self {
  if P {
- assert!(!rb.rb().write_is_held());
- unsafe { rb.rb().hold_write(true) };
+ assert!(!unsafe { rb.rb().hold_write(true) });
  }
  if C {
- assert!(!rb.rb().read_is_held());
- unsafe { rb.rb().hold_read(true) };
+ assert!(!unsafe { rb.rb().hold_read(true) });
  }
  unsafe { Self::new_unchecked(rb) }
  }