forked from Orchid/orchid
Lawrence Bethlenfalvy
09cfcb1839
I got very confused and started mucking about with "spawn" when in fact all I needed was the "inline" extension type in orcx that allows the interpreter to expose custom constants.
100 lines
3.1 KiB
Rust
100 lines
3.1 KiB
Rust
use std::cell::RefCell;
|
|
use std::num::{NonZero, NonZeroU16};
|
|
use std::rc::{Rc, Weak};
|
|
use std::time::Duration;
|
|
use std::{fmt, ops};
|
|
|
|
use futures::future::LocalBoxFuture;
|
|
use futures_locks::RwLock;
|
|
use hashbrown::HashMap;
|
|
|
|
use crate::api;
|
|
use crate::expr_store::ExprStore;
|
|
use crate::logger::LoggerImpl;
|
|
use crate::system::{System, WeakSystem};
|
|
use crate::tree::WeakRoot;
|
|
|
|
pub trait JoinHandle {
|
|
/// It is guaranteed that the future will never be polled after this is called
|
|
fn abort(&self);
|
|
/// take the future out of the task. If the return value
|
|
/// is dropped, the spawned future is also dropped
|
|
fn join(self: Box<Self>) -> LocalBoxFuture<'static, ()>;
|
|
}
|
|
|
|
pub trait Spawner {
|
|
/// Spawn a future off-task, but in the same thread. If all objects associated
|
|
/// with the owning [Ctx] are dropped (eg. expressions, extensions, systems)
|
|
/// and no extensions create permanent ref loops, then all tasks will
|
|
/// eventually settle, therefore the implementor of this interface should not
|
|
/// exit while there are pending tasks to allow external communication
|
|
/// channels to cleanly shut down.
|
|
fn spawn_obj(&self, delay: Duration, fut: LocalBoxFuture<'static, ()>) -> Box<dyn JoinHandle>;
|
|
}
|
|
|
|
pub struct CtxData {
|
|
spawner: Rc<dyn Spawner>,
|
|
pub systems: RwLock<HashMap<api::SysId, WeakSystem>>,
|
|
pub system_id: RefCell<NonZeroU16>,
|
|
pub exprs: ExprStore,
|
|
pub root: RwLock<WeakRoot>,
|
|
pub logger: LoggerImpl,
|
|
}
|
|
#[derive(Clone)]
|
|
pub struct Ctx(Rc<CtxData>);
|
|
impl ops::Deref for Ctx {
|
|
type Target = CtxData;
|
|
fn deref(&self) -> &Self::Target { &self.0 }
|
|
}
|
|
#[derive(Clone)]
|
|
pub struct WeakCtx(Weak<CtxData>);
|
|
impl WeakCtx {
|
|
#[must_use]
|
|
pub fn try_upgrade(&self) -> Option<Ctx> { Some(Ctx(self.0.upgrade()?)) }
|
|
#[must_use]
|
|
pub fn upgrade(&self) -> Ctx { self.try_upgrade().expect("Ctx manually kept alive until exit") }
|
|
}
|
|
impl Ctx {
|
|
#[must_use]
|
|
pub fn new(spawner: impl Spawner + 'static, logger: LoggerImpl) -> Self {
|
|
Self(Rc::new(CtxData {
|
|
spawner: Rc::new(spawner),
|
|
systems: RwLock::default(),
|
|
system_id: RefCell::new(NonZero::new(1).unwrap()),
|
|
exprs: ExprStore::default(),
|
|
root: RwLock::default(),
|
|
logger,
|
|
}))
|
|
}
|
|
/// Spawn a parallel future that you can join at any later time.
|
|
///
|
|
/// Don't use this for async Drop, use [orchid_base::stash] instead.
|
|
/// If you use this for an actor object, make sure to actually join the
|
|
/// handle.
|
|
#[must_use]
|
|
pub fn spawn(
|
|
&self,
|
|
delay: Duration,
|
|
fut: impl Future<Output = ()> + 'static,
|
|
) -> Box<dyn JoinHandle> {
|
|
self.spawner.spawn_obj(delay, Box::pin(fut))
|
|
}
|
|
#[must_use]
|
|
pub(crate) async fn system_inst(&self, id: api::SysId) -> Option<System> {
|
|
self.systems.read().await.get(&id).and_then(WeakSystem::upgrade)
|
|
}
|
|
#[must_use]
|
|
pub(crate) fn next_sys_id(&self) -> api::SysId {
|
|
let mut g = self.system_id.borrow_mut();
|
|
*g = g.checked_add(1).unwrap_or(NonZeroU16::new(1).unwrap());
|
|
api::SysId(*g)
|
|
}
|
|
#[must_use]
|
|
pub fn downgrade(&self) -> WeakCtx { WeakCtx(Rc::downgrade(&self.0)) }
|
|
}
|
|
impl fmt::Debug for Ctx {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
f.debug_struct("Ctx").field("system_id", &self.system_id).finish_non_exhaustive()
|
|
}
|
|
}
|