use std::sync::Arc;
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use nagoya::sync::{Notify, RwLock};
#[derive(Debug)]
pub struct Latest<T> {
slot: RwLock<Option<T>>,
changed: Notify,
revision: AtomicU64,
}
impl<T: Clone> Latest<T> {
#[must_use]
pub fn new() -> Arc<Self> {
Arc::new(Self {
slot: RwLock::new(None),
changed: Notify::new(),
revision: AtomicU64::new(0),
})
}
pub async fn set(&self, value: T) {
*self.slot.write().await = Some(value);
self.revision.fetch_add(1, Ordering::Release);
self.changed.notify_waiters();
}
pub fn set_now(&self, value: T) -> bool {
let Some(mut slot) = self.slot.try_write() else {
return false;
};
*slot = Some(value);
drop(slot);
self.revision.fetch_add(1, Ordering::Release);
self.changed.notify_waiters();
true
}
pub async fn get(&self) -> Option<T> {
self.slot.read().await.clone()
}
#[must_use]
pub fn revision(&self) -> u64 {
self.revision.load(Ordering::Acquire)
}
pub async fn changed_since(&self, seen: u64) -> (Option<T>, u64) {
loop {
let notified = self.changed.notified();
futures::pin_mut!(notified);
let ready = notified.as_mut().enable();
let now = self.revision();
if now != seen {
return (self.get().await, now);
}
if !ready {
notified.await;
}
}
}
}
#[derive(Debug)]
pub struct Once<T> {
state: RwLock<(Option<T>, bool)>,
ready: Notify,
}
impl<T> Once<T> {
#[must_use]
pub fn new() -> Arc<Self> {
Arc::new(Self {
state: RwLock::new((None, false)),
ready: Notify::new(),
})
}
pub fn fill(&self, value: T) -> bool {
let mut state = loop {
match self.state.try_write() {
Some(state) => break state,
None => std::thread::yield_now(),
}
};
if state.0.is_some() || state.1 {
return false;
}
state.0 = Some(value);
state.1 = true;
drop(state);
self.ready.notify_waiters();
true
}
pub async fn send(&self, value: T) {
{
let mut state = self.state.write().await;
if state.0.is_none() {
state.0 = Some(value);
}
state.1 = true;
}
self.ready.notify_waiters();
}
pub async fn abandon(&self) {
self.state.write().await.1 = true;
self.ready.notify_waiters();
}
pub async fn recv(&self) -> Option<T> {
loop {
let notified = self.ready.notified();
futures::pin_mut!(notified);
let ready = notified.as_mut().enable();
{
let mut state = self.state.write().await;
if let Some(value) = state.0.take() {
return Some(value);
}
if state.1 {
return None;
}
}
if !ready {
notified.await;
}
}
}
}
#[derive(Debug, Default)]
pub struct Flag {
set: AtomicBool,
raised: Notify,
}
impl Flag {
#[must_use]
pub fn new() -> Arc<Self> {
Arc::new(Self {
set: AtomicBool::new(false),
raised: Notify::new(),
})
}
pub fn raise(&self) {
self.set.store(true, Ordering::Release);
self.raised.notify_waiters();
}
#[must_use]
pub fn is_raised(&self) -> bool {
self.set.load(Ordering::Acquire)
}
pub async fn raised(&self) {
loop {
let notified = self.raised.notified();
futures::pin_mut!(notified);
let ready = notified.as_mut().enable();
if self.is_raised() {
return;
}
if ready {
continue;
}
notified.await;
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_value_sent_before_the_first_poll_is_not_lost() {
let once = Once::<u8>::new();
let writer = Arc::clone(&once);
nagoya::block_on(async move {
writer.send(7).await;
assert_eq!(once.recv().await, Some(7));
});
}
#[test]
fn an_abandoned_slot_answers_none() {
let once = Once::<u8>::new();
let writer = Arc::clone(&once);
nagoya::block_on(async move {
writer.abandon().await;
assert_eq!(once.recv().await, None);
});
}
#[test]
fn a_value_is_delivered_once() {
let once = Once::<u8>::new();
let writer = Arc::clone(&once);
nagoya::block_on(async move {
writer.send(1).await;
assert_eq!(once.recv().await, Some(1));
assert_eq!(once.recv().await, None);
});
}
#[test]
fn latest_retains_only_the_newest() {
let latest = Latest::<u8>::new();
nagoya::block_on(async move {
latest.set(1).await;
latest.set(2).await;
latest.set(3).await;
assert_eq!(latest.get().await, Some(3));
});
}
}