Struct WorldThread 

pub struct WorldThread {
    status: ThreadStatus,
    joined: Option<JoinHandle<()>>,
}

One thread owning one World.

Dropping the thread asks it to stop and waits for it to finish, so a threaded world’s lifetime is exactly the proxy’s. A tick that ignores the stop cannot hang the dropper: after a short grace period the thread is detached and the drop returns.

Fields

status: ThreadStatus

The shared state a handle reports.

joined: Option<JoinHandle<()>>

The thread handle, joined on drop.

Implementations

impl WorldThread

pub fn spawn<T>(name: &str, tick: T) -> Self

where T: FnMut(&mut World, &ThreadControl) -> bool + Send + 'static,

Spawn a thread that owns a fresh World and ticks it forever.

The tick runs once per loop iteration and returns whether to keep running; a false return ends the thread as cleanly as a stop. A tick panic is caught, logged and published as the world’s state, and ends the thread: a world whose tick has panicked is not worth restarting blindly.

pub fn spawn_with<S, I, T>(name: &str, init: I, tick: T) -> Self

where I: FnOnce(&mut World) -> S + Send + 'static, T: FnMut(&mut World, &ThreadControl, &mut S) -> bool + Send + 'static,

Like spawn, with a setup step and the state it produces.

init runs once on the thread, against the fresh world, before the first job is drained; whatever it returns is handed to every tick. That ordering is what lets a bridge create the components its jobs assume exist - the physics world with its configured gravity, say - so a job sent immediately after spawning already finds them.

pub(crate) fn status(&self) -> ThreadStatus

A cloneable view of the thread’s state, for the handle the spawn hands back.

pub fn state(&self) -> SnapshotReader<WorldState>

A reader of the state the world publishes.

pub fn is_finished(&self) -> bool

Whether the thread has exited.

A detached thread keeps reporting its own exit, so this stays meaningful after detach.

pub fn stop(&self)

Ask the thread to stop, without waiting for it to finish.

pub fn join_timeout(&mut self, timeout: Duration) -> bool

Wait up to timeout for the thread to finish.

Returns whether it finished in time. A thread that already finished, or was detached, counts as finished. The wait is woken by the thread itself as it leaves its loop, so it costs nothing while the thread runs.

pub fn detach(&mut self)

Leave the thread running without ever joining it.

The thread stops when it notices the stop, but nothing waits for it.

fn join(&mut self)

Join the thread, clearing the handle.

Trait Implementations

impl Drop for WorldThread

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.