Struct netsblox_vm::process::Process

pub struct Process<'gc, C: CustomTypes<S>, S: System<C>> {
    pub global_context: Gc<'gc, RefLock<GlobalContext<'gc, C, S>>>,
    pub state: C::ProcessState,
    /* private fields */
}

A ByteCode execution primitive.

A Process is a self-contained thread of execution. It maintains its own state machine for executing instructions step by step.

Fields

global_context: Gc<'gc, RefLock<GlobalContext<'gc, C, S>>>

state: C::ProcessState

Implementations

impl<'gc, C: CustomTypes<S>, S: System<C>> Process<'gc, C, S>

pub fn new(context: ProcContext<'gc, C, S>) -> Self

Creates a new Process with the given starting context.

pub fn is_running(&self) -> bool

Checks if the process is currently running. Note that the process will not run on its own (see Process::step).

pub fn current_entity(&self) -> Gc<'gc, RefLock<Entity<'gc, C, S>>>

Gets the current active entity of this process. Note that this is not necessarily the same entity that was used to construct the process, as blocks such as “tell _ to _” and “ask _ for _” can change the context entity.

pub fn step( &mut self, mc: &Mutation<'gc> ) -> Result<ProcessStep<'gc, C, S>, ExecError<C, S>>

Executes a single bytecode instruction. The return value can be used to determine what additional effects the script has requested, as well as to retrieve the return value or execution error in the event that the process terminates.

The process transitions to the idle state (see Process::is_running) upon failing with Err or succeeding with ProcessStep::Terminate.

Trait Implementations

impl<'gc, C: CustomTypes<S>, S: System<C>> Collect for Process<'gc, C, S>where C::ProcessState: 'static, usize: 'static, bool: 'static, Option<Barrier>: 'static, Option<S::InternReplyKey>: 'static, Vec<Handler>: 'static, Option<Defer<C, S>>: 'static,

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.