63 lines
1.7 KiB
Rust
63 lines
1.7 KiB
Rust
//! In dioxus, effects are run using normal async functions after a render. [RenderSignalFuture] is a future that resolves after a render has passed.
|
|
|
|
use std::cell::RefCell;
|
|
use std::future::Future;
|
|
use std::pin::Pin;
|
|
use std::rc::Rc;
|
|
use std::task::Context;
|
|
use std::task::Poll;
|
|
use std::task::Waker;
|
|
|
|
/// A signal is a message that can be sent to all listening tasks at once
|
|
#[derive(Default)]
|
|
pub struct RenderSignal {
|
|
wakers: Rc<RefCell<Vec<Rc<RefCell<RenderSignalFutureInner>>>>>,
|
|
}
|
|
|
|
impl RenderSignal {
|
|
/// Send the signal to all listening tasks
|
|
pub fn send(&self) {
|
|
let mut wakers = self.wakers.borrow_mut();
|
|
for waker in wakers.drain(..) {
|
|
let mut inner = waker.borrow_mut();
|
|
inner.resolved = true;
|
|
if let Some(waker) = inner.waker.take() {
|
|
waker.wake();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Create a future that resolves when the signal is sent
|
|
pub fn subscribe(&self) -> RenderSignalFuture {
|
|
let inner = Rc::new(RefCell::new(RenderSignalFutureInner {
|
|
resolved: false,
|
|
waker: None,
|
|
}));
|
|
self.wakers.borrow_mut().push(inner.clone());
|
|
RenderSignalFuture { inner }
|
|
}
|
|
}
|
|
|
|
struct RenderSignalFutureInner {
|
|
resolved: bool,
|
|
waker: Option<Waker>,
|
|
}
|
|
|
|
pub(crate) struct RenderSignalFuture {
|
|
inner: Rc<RefCell<RenderSignalFutureInner>>,
|
|
}
|
|
|
|
impl Future for RenderSignalFuture {
|
|
type Output = ();
|
|
|
|
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
|
|
let mut inner = self.inner.borrow_mut();
|
|
if inner.resolved {
|
|
Poll::Ready(())
|
|
} else {
|
|
inner.waker = Some(cx.waker().clone());
|
|
Poll::Pending
|
|
}
|
|
}
|
|
}
|