Struct piccolo::thread::Executor

pub struct Executor<'gc>(/* private fields */);

The entry-point for the Lua VM.

Executor runs networks of Threads that may depend on each other and may pass control back and forth. All Lua code that is run is done so directly or indirectly by calling Executor::step.

Panics

Executor is dangerous to use from within any kind of Lua callback. It has no protection against re-entrency, and calling Executor methods from within a callback that it is running (other than Executor::mode) will panic. Additionally, even if an independent Executor is used, cross-thread upvalues may cause a panic if one Executor is used within the other.

Executors are not meant to be used from callbacks at all, and Executors should not be nested. Instead, use the normal mechanisms for callbacks to call Lua code so that it is run on the same executor calling the callback.

Implementations

impl<'gc> Executor<'gc>

pub fn new(ctx: Context<'gc>) -> Self

Creates a new Executor with a stopped main thread.

pub fn run(mc: &Mutation<'gc>, thread: Thread<'gc>) -> Self

Creates a new Executor that begins running the given thread.

pub fn from_inner(inner: Gc<'gc, ExecutorInner<'gc>>) -> Self

pub fn into_inner(self) -> Gc<'gc, ExecutorInner<'gc>>

pub fn start( ctx: Context<'gc>, function: Function<'gc>, args: impl IntoMultiValue<'gc> ) -> Self

Creates a new Executor with a new Thread running the given function.

pub fn mode(self) -> ExecutorMode

pub fn step(self, ctx: Context<'gc>, fuel: &mut Fuel) -> bool

Runs the VM for a period of time controlled by the fuel parameter.

The VM and callbacks will consume fuel as they run, and Executor::step will return as soon as Fuel::can_continue() returns false and some minimal positive progress has been made.

Returns false if the method has exhausted its fuel, but there is more work to do, and returns true if no more progress can be made. If true is returned, then Executor::mode() will no longer be ExecutorMode::Normal.

pub fn take_result<T: FromMultiValue<'gc>>( self, ctx: Context<'gc> ) -> Result<Result<T, Error<'gc>>, BadExecutorMode>

pub fn resume( self, ctx: Context<'gc>, args: impl IntoMultiValue<'gc> ) -> Result<(), BadExecutorMode>

pub fn resume_err( self, mc: &Mutation<'gc>, error: Error<'gc> ) -> Result<(), BadExecutorMode>

pub fn stop(self, mc: &Mutation<'gc>)

Reset this Executor entirely, leaving it with a stopped main thread. Equivalent to creating a new executor with Executor::new.

pub fn reset(self, mc: &Mutation<'gc>, thread: Thread<'gc>)

Reset this Executor entirely and begins running the given thread. Equivalent to creating a new executor with Executor::run.

pub fn restart( self, ctx: Context<'gc>, function: Function<'gc>, args: impl IntoMultiValue<'gc> )

Reset this Executor entirely and begins running the given function, equivalent to creating a new executor with Executor::start.

Trait Implementations

impl<'gc> Clone for Executor<'gc>

fn clone(&self) -> Executor<'gc>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'gc> Collect for Executor<'gc>

fn needs_trace() -> bool

As an optimization, if this type can never hold a Gc pointer and trace is unnecessary to call, you may implement this method and return false. The default implementation returns true, signaling that Collect::trace must be called.

fn trace(&self, cc: &Collection)

Must call Collect::trace on all held Gc pointers. If this type holds inner types that implement Collect, a valid implementation would simply call Collect::trace on all the held values to ensure this.

impl<'gc> Debug for Executor<'gc>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'gc> Hash for Executor<'gc>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'gc> PartialEq for Executor<'gc>

fn eq(&self, other: &Executor<'gc>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'gc> Stashable<'gc> for Executor<'gc>

type Stashed = StashedExecutor

fn stash(self, roots: &DynamicRootSet<'gc>, mc: &Mutation<'gc>) -> Self::Stashed

impl<'gc> Copy for Executor<'gc>

impl<'gc> Eq for Executor<'gc>