Struct 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 get_call_stack(&self) -> &[CallFrame<'gc, C, S>]

Gets a reference to the current call stack. This is a sequence of every call frame, including the current context entity, local variables in scope, and other hidden state information. Due to the delicate state involved, a mutable option is not supported.

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.

This function is not re-entrant, so recursively calling it from the mutable handle of, e.g., Config will likely lead to panics.

Trait Implementations

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

where C::ProcessState: 'static, usize: 'static, Option<Barrier>: 'static, Option<InternReplyKey>: 'static, Vec<Handler<C, S>>: '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.