Struct rune::runtime::VmExecution

pub struct VmExecution<T = Vm>
where
    T: AsRef<Vm> + AsMut<Vm>,
{ /* private fields */ }

The execution environment for a virtual machine.

When an execution is dropped, the stack of the stack of the head machine will be cleared.

Implementations

impl<T> VmExecution<T>

where T: AsRef<Vm> + AsMut<Vm>,

pub fn into_generator(self) -> Generator<T>

Coerce the current execution into a generator if appropriate.

use rune::Vm;
use std::sync::Arc;

let mut sources = rune::sources! {
    entry => {
        pub fn main() {
            yield 1;
            yield 2;
        }
    }
};

let unit = rune::prepare(&mut sources).build()?;

let mut vm = Vm::without_runtime(Arc::new(unit));
let mut generator = vm.execute(["main"], ())?.into_generator();

let mut n = 1i64;

while let Some(value) = generator.next().into_result()? {
    let value: i64 = rune::from_value(value)?;
    assert_eq!(value, n);
    n += 1;
}

pub fn into_stream(self) -> Stream<T>

Coerce the current execution into a stream if appropriate.

use rune::Vm;
use std::sync::Arc;

let mut sources = rune::sources! {
    entry => {
        pub async fn main() {
            yield 1;
            yield 2;
        }
    }
};

let unit = rune::prepare(&mut sources).build()?;

let mut vm = Vm::without_runtime(Arc::new(unit));
let mut stream = vm.execute(["main"], ())?.into_stream();

let mut n = 1i64;

while let Some(value) = stream.next().await.into_result()? {
    let value: i64 = rune::from_value(value)?;
    assert_eq!(value, n);
    n += 1;
}

pub fn vm(&self) -> &Vm

Get a reference to the current virtual machine.

pub fn vm_mut(&mut self) -> &mut Vm

Get a mutable reference the current virtual machine.

pub async fn async_complete(&mut self) -> VmResult<Value>

Complete the current execution without support for async instructions.

This will error if the execution is suspended through yielding.

pub fn complete(&mut self) -> VmResult<Value>

Complete the current execution without support for async instructions.

If any async instructions are encountered, this will error. This will also error if the execution is suspended through yielding.

pub async fn async_resume_with( &mut self, value: Value ) -> VmResult<GeneratorState>

Resume the current execution with the given value and resume asynchronous execution.

pub async fn async_resume(&mut self) -> VmResult<GeneratorState>

Resume the current execution with support for async instructions.

If the function being executed is a generator or stream this will resume it while returning a unit from the current yield.

pub fn resume_with(&mut self, value: Value) -> VmResult<GeneratorState>

Resume the current execution with the given value and resume synchronous execution.

pub fn resume(&mut self) -> VmResult<GeneratorState>

Resume the current execution without support for async instructions.

If the function being executed is a generator or stream this will resume it while returning a unit from the current yield.

If any async instructions are encountered, this will error.

pub fn step(&mut self) -> VmResult<Option<Value>>

Step the single execution for one step without support for async instructions.

If any async instructions are encountered, this will error.

pub async fn async_step(&mut self) -> VmResult<Option<Value>>

Step the single execution for one step with support for async instructions.

impl VmExecution<&mut Vm>

pub fn into_owned(self) -> VmExecution<Vm>

Convert the current execution into one which owns its virtual machine.