zuzu-rust 0.3.0

Rust implementation of ZuzuScript
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

use std::future::Future;

use tokio::runtime::{Builder, Runtime as TokioRuntime};
use tokio::task::LocalSet;

pub(in crate::runtime) struct AsyncExecutor {
    runtime: TokioRuntime,
    local: LocalSet,
}

impl AsyncExecutor {
    pub(in crate::runtime) fn new() -> Self {
        let runtime = Builder::new_current_thread()
            .enable_io()
            .enable_time()
            .build()
            .expect("zuzu-rust async executor should initialize");
        Self {
            runtime,
            local: LocalSet::new(),
        }
    }

    pub(in crate::runtime) fn block_on<F>(&self, future: F) -> F::Output
    where
        F: Future,
    {
        self.local.block_on(&self.runtime, future)
    }

    pub(in crate::runtime) fn spawn_local<F>(&self, future: F)
    where
        F: Future<Output = ()> + 'static,
    {
        self.local.spawn_local(future);
    }

    pub(in crate::runtime) fn enter<T>(&self, f: impl FnOnce() -> T) -> T {
        let _guard = self.runtime.enter();
        f()
    }

    pub(in crate::runtime) fn sleep_until(&self, deadline: std::time::Instant) {
        let now = std::time::Instant::now();
        if deadline <= now {
            self.block_on(tokio::task::yield_now());
            return;
        }
        self.block_on(tokio::time::sleep_until(tokio::time::Instant::from_std(
            deadline,
        )));
    }

    pub(in crate::runtime) fn sleep_for(&self, duration: std::time::Duration) {
        if duration.is_zero() {
            return;
        }
        self.block_on(tokio::time::sleep(duration));
    }
}