Struct HandleScope 

pub struct HandleScope<'m> { /* private fields */ }

A region in which native code can root values across calls back into the interpreter (which may collect). Handles borrow the scope, so the borrow checker keeps them from escaping it; dropping the scope releases them.

let scope = HandleScope::new(&mut vm.m);
let list = scope.root(make_list(scope.mutator()));
vm_call_that_may_collect();
let still_valid = scope.get(list);

Implementations

impl<'m> HandleScope<'m>

pub fn new(m: &'m mut Mutator) -> Self

pub unsafe fn detached(m: *mut Mutator) -> HandleScope<'static>

A scope that does not borrow the mutator, so native code can keep calling into the VM while it holds handles. Handles still cannot outlive the scope.

Safety

m must outlive the scope and belong to the current thread.

pub fn root<'s>(&'s self, v: Value) -> Local<'s>

Roots v until the scope ends.

pub fn get(&self, h: Local<'_>) -> Value

pub fn set(&self, h: Local<'_>, v: Value)

pub fn mutator(&self) -> &mut Mutator

The mutator, for allocation. Allocation never collects, so handles stay valid.

Trait Implementations

impl Drop for HandleScope<'_>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.