Struct VmExecution 

pub struct VmExecution<T> { /* 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>

pub fn vm(&self) -> &Vm

where T: AsRef<Vm>,

Get a reference to the current virtual machine.

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

where T: AsMut<Vm>,

Get a mutable reference the current virtual machine.

impl<T> VmExecution<T>

where T: AsMut<Vm>,

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

Coerce the current execution into a generator if appropriate.

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

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

let unit = rune::prepare(&mut sources).build()?;
let unit = Arc::try_new(unit)?;
let mut vm = Vm::without_runtime(unit)?;

let mut generator = vm.execute(["main"], ())?.into_generator();

let mut n = 1i64;

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

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

Coerce the current execution into a stream if appropriate.

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

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

let unit = rune::prepare(&mut sources).build()?;
let unit = Arc::try_new(unit)?;
let mut vm = Vm::without_runtime(unit)?;

let mut stream = vm.execute(["main"], ())?.into_stream();

let mut n = 1i64;

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

impl<T> VmExecution<T>

where T: AsMut<Vm>,

pub fn complete(&mut self) -> Result<Value, VmError>

Synchronously complete the current execution.

Errors

If anything except the completion of the execution is encountered, this will result in an error.

To handle other outcomes and more configurability see VmExecution::resume.

pub async fn async_complete(&mut self) -> Result<Value, VmError>

Asynchronously complete the current execution.

Errors

If anything except the completion of the execution is encountered, this will result in an error.

To handle other outcomes and more configurability see VmExecution::resume.

pub fn resume(&mut self) -> VmResume<'_, 'static, T>

Resume the current execution.

To complete this operation synchronously, use VmResume::complete.

Resume with a value

To resume an execution with a value, use VmResume::with_value. This requires that the execution has yielded first, otherwise an error will be produced.

Resume with diagnostics

To associated VmDiagnostics with the execution, use VmResume::with_diagnostics.

impl VmExecution<&mut Vm>

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

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

Trait Implementations

impl<T> TryClone for VmExecution<T>

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

fn try_clone(&self) -> Result<Self, Error>

Try to clone the current value, raising an allocation error if it’s unsuccessful.

fn try_clone_from(&mut self, source: &Self) -> Result<(), Error>

Performs copy-assignment from source.