use std::future::Future;
use std::pin::Pin;
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::sync::{Mutex, MutexGuard};
use std::task::{Context, Poll, Waker};
use crate::event::PauseReason;
use crate::pool::Selector;
use crate::value::Value;
#[derive(Clone, Debug, PartialEq, Eq)]
pub(crate) enum Stop {
Abort(String),
Fail(String),
}
#[derive(Debug, Default)]
pub(crate) struct Control {
version: AtomicU64,
stopped: AtomicBool,
stop: Mutex<Option<Stop>>,
pause_requested: AtomicBool,
reasons: Mutex<Vec<PauseReason>>,
updates: Mutex<Vec<(Selector, Value)>>,
wakers: Mutex<Vec<Waker>>,
}
fn lock<T>(m: &Mutex<T>) -> MutexGuard<'_, T> {
m.lock().unwrap_or_else(std::sync::PoisonError::into_inner)
}
impl Control {
pub(crate) fn version(&self) -> u64 {
self.version.load(Ordering::Acquire)
}
fn notify(&self) {
self.version.fetch_add(1, Ordering::AcqRel);
let wakers: Vec<Waker> = std::mem::take(&mut *lock(&self.wakers));
for w in wakers {
w.wake();
}
}
pub(crate) fn stop(&self, stop: Stop) {
{
let mut slot = lock(&self.stop);
if slot.is_none() {
*slot = Some(stop);
}
}
self.stopped.store(true, Ordering::Release);
self.notify();
}
pub(crate) fn is_stopped(&self) -> bool {
self.stopped.load(Ordering::Acquire)
}
pub(crate) fn stop_reason(&self) -> Option<Stop> {
lock(&self.stop).clone()
}
pub(crate) fn request_pause(&self, reason: Option<PauseReason>) {
if let Some(r) = reason {
lock(&self.reasons).push(r);
}
self.pause_requested.store(true, Ordering::Release);
self.notify();
}
pub(crate) fn pause_requested(&self) -> bool {
self.pause_requested.load(Ordering::Acquire)
}
pub(crate) fn add_reason(&self, reason: PauseReason) {
lock(&self.reasons).push(reason);
}
pub(crate) fn reasons(&self) -> Vec<PauseReason> {
lock(&self.reasons).clone()
}
pub(crate) fn push_update(&self, selector: Selector, value: Value) {
lock(&self.updates).push((selector, value));
self.notify();
}
pub(crate) fn take_updates(&self) -> Vec<(Selector, Value)> {
std::mem::take(&mut *lock(&self.updates))
}
pub(crate) fn changed(&self, seen: u64) -> Changed<'_> {
Changed { control: self, seen }
}
}
#[derive(Debug)]
pub(crate) struct Changed<'a> {
control: &'a Control,
seen: u64,
}
impl Future for Changed<'_> {
type Output = ();
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
if self.control.version() != self.seen {
return Poll::Ready(());
}
{
let mut wakers = lock(&self.control.wakers);
if !wakers.iter().any(|w| w.will_wake(cx.waker())) {
wakers.push(cx.waker().clone());
}
}
if self.control.version() != self.seen { Poll::Ready(()) } else { Poll::Pending }
}
}