use alloc::sync::{Arc, Weak};
use alloc::vec::Vec;
use core::future::Future;
use core::pin::Pin;
use core::sync::atomic::{AtomicBool, Ordering};
use core::task::{Context, Poll, Waker};
use core::cell::RefCell;
type WakerList = critical_section::Mutex<RefCell<Vec<Waker>>>;
struct TokenInner {
flag: AtomicBool,
parent: Option<Weak<TokenInner>>,
wakers: WakerList,
}
impl TokenInner {
fn is_cancelled(&self) -> bool {
if self.flag.load(Ordering::Acquire) {
return true;
}
let mut ancestor = self.parent.as_ref().and_then(Weak::upgrade);
while let Some(node) = ancestor {
if node.flag.load(Ordering::Acquire) {
return true;
}
ancestor = node.parent.as_ref().and_then(Weak::upgrade);
}
false
}
fn wake_all(&self) {
let drained =
critical_section::with(|cs| core::mem::take(&mut *self.wakers.borrow_ref_mut(cs)));
for w in drained {
w.wake();
}
}
}
#[derive(Clone)]
pub struct CancellationToken {
inner: Arc<TokenInner>,
}
impl CancellationToken {
pub fn new() -> Self {
Self {
inner: Arc::new(TokenInner {
flag: AtomicBool::new(false),
parent: None,
wakers: critical_section::Mutex::new(RefCell::new(Vec::new())),
}),
}
}
pub fn cancel(&self) {
self.inner.flag.store(true, Ordering::Release);
self.inner.wake_all();
}
pub fn is_cancelled(&self) -> bool {
self.inner.is_cancelled()
}
pub fn child_token(&self) -> CancellationToken {
CancellationToken {
inner: Arc::new(TokenInner {
flag: AtomicBool::new(false),
parent: Some(Arc::downgrade(&self.inner)),
wakers: critical_section::Mutex::new(RefCell::new(Vec::new())),
}),
}
}
pub fn cancelled(&self) -> Cancelled<'_> {
Cancelled { token: self }
}
}
impl Default for CancellationToken {
fn default() -> Self {
Self::new()
}
}
pub struct Cancelled<'a> {
token: &'a CancellationToken,
}
impl Future for Cancelled<'_> {
type Output = ();
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
let inner = &self.token.inner;
if inner.is_cancelled() {
return Poll::Ready(());
}
let waker = cx.waker();
let mut node = Some(Arc::clone(inner));
while let Some(n) = node {
critical_section::with(|cs| {
let mut list = n.wakers.borrow_ref_mut(cs);
if !list.iter().any(|w| w.will_wake(waker)) {
list.push(waker.clone());
}
});
node = n.parent.as_ref().and_then(Weak::upgrade);
}
Poll::Pending
}
}