actuate 0.21.0

A reactive user-interface framework
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

use alloc::{rc::Rc, sync::Arc};
use core::{future::Future, pin::Pin};

/// Executor for async tasks.
pub trait Executor {
    /// Spawn a boxed future on this executor.
    fn spawn(&self, future: Pin<Box<dyn Future<Output = ()> + Send>>);
}

#[cfg(feature = "rt")]
#[cfg_attr(docsrs, doc(cfg(feature = "rt")))]
impl Executor for tokio::runtime::Runtime {
    fn spawn(&self, future: Pin<Box<dyn Future<Output = ()> + Send>>) {
        self.spawn(future);
    }
}

macro_rules! impl_executor {
    ($($t:tt),*) => {
        $(
            impl<T: Executor + ?Sized> Executor for $t<T> {
                fn spawn(&self, future: Pin<Box<dyn Future<Output = ()> + Send>>) {
                    (**self).spawn(future);
                }
            }
        )*
    };
}

impl_executor!(Box, Rc, Arc);

/// Context that contains the current [`Executor`].
pub struct ExecutorContext {
    pub(crate) executor: Box<dyn Executor>,
}

#[cfg(feature = "rt")]
impl Default for ExecutorContext {
    fn default() -> Self {
        Self::new(tokio::runtime::Runtime::new().unwrap())
    }
}

impl ExecutorContext {
    /// Create a new [`ExecutorContext`] with the provided [`Executor`].
    pub fn new(executor: impl Executor + 'static) -> Self {
        Self {
            executor: Box::new(executor),
        }
    }

    /// Spawn a future on the current runtime.
    pub fn spawn<F>(&self, future: F)
    where
        F: Future<Output = ()> + Send + 'static,
    {
        self.spawn_boxed(Box::pin(future))
    }

    /// Spawn a boxed future on the current runtime.
    pub fn spawn_boxed(&self, future: Pin<Box<dyn Future<Output = ()> + Send>>) {
        self.executor.spawn(future);
    }
}