Struct RootedGuard 

pub struct RootedGuard<'a, T: 'a + RootKind> {
    root: *mut Rooted<T>,
    anchor: PhantomData<&'a mut Rooted<T>>,
}

Rust API for keeping a Rooted value in the context’s root stack. Example usage: rooted!(in(cx) let x = UndefinedValue());. RootedGuard::new also works, but the macro is preferred.

Fields

root: *mut Rooted<T>

anchor: PhantomData<&'a mut Rooted<T>>

Implementations

impl<'a, T: 'a + RootKind> RootedGuard<'a, T>

pub fn new( cx: *mut JSContext, root: &'a mut MaybeUninit<Rooted<T>>, initial: T, ) -> Self

pub fn handle(&'a self) -> Handle<'a, T>

pub fn handle_mut(&mut self) -> MutableHandle<'_, T>

pub fn as_ptr(&self) -> *mut T

pub fn as_ref<'s: 'r, 'cx: 'r, 'r>(&'s self, _no_gc: &'cx NoGC) -> &'r T

where 'a: 's,

Obtains a reference to the value pointed to by this handle. While this reference is alive, no GC can occur, because of the _no_gc argument:

use mozjs::context::*;
use mozjs::jsapi::JSObject;
use mozjs::rooted;

fn gc(cx: &mut JSContext) {}

fn f(cx: &mut JSContext, obj: *mut JSObject) {
    rooted!(&in(cx) let mut root = obj);
    let r = root.as_ref(cx);
    gc(cx); // cannot call gc while r (thus cx borrow) is alive
    drop(r); // otherwise rust automatically drops r before gc call
}

pub fn as_mut_ref<'s: 'r, 'cx: 'r, 'r>( &'s mut self, _no_gc: &'cx NoGC, ) -> &'r mut T

where 'a: 's,

Obtains a reference to the value pointed to by this handle. While this reference is alive, no GC can occur, because of the _no_gc argument:

use mozjs::context::*;
use mozjs::jsapi::JSObject;
use mozjs::rooted;

fn gc(cx: &mut JSContext) {}

fn f(cx: &mut JSContext, obj: *mut JSObject) {
    rooted!(&in(cx) let mut root = obj);
    let r = root.as_mut_ref(cx);
    gc(cx); // cannot call gc while r (thus cx borrow) is alive
    drop(r); // otherwise rust automatically drops r before gc call
}

pub unsafe fn as_mut<'b>(&'b mut self) -> &'b mut T

where 'a: 'b,

Safety: GC must not run during the lifetime of the returned reference. Prefer using RootedGuard::as_mut_ref instead.

pub fn get(&self) -> T

where T: Copy,

pub fn set(&mut self, v: T)

impl<'a, T> RootedGuard<'a, Option<T>>

where Option<T>: RootKind,

pub fn take(&mut self) -> Option<T>

impl<'a, T> RootedGuard<'a, Vec<T>>

where Vec<T>: RootKind,

pub fn push(&mut self, value: T)

pub fn extend(&mut self, iterator: impl Iterator<Item = T>)

pub fn set_index(&mut self, index: usize, value: T)

pub fn handle_at(&self, index: usize) -> Handle<'_, T>

pub fn handle_mut_at(&mut self, index: usize) -> MutableHandle<'_, T>

Trait Implementations

impl<'a, T: 'a + RootKind> Deref for RootedGuard<'a, T>

fn deref(&self) -> &T

This is unsound and will be removed eventually. Use RootedGuard::as_ref instead.

type Target = T

The resulting type after dereferencing.

impl<'a, T: 'a + RootKind> Drop for RootedGuard<'a, T>

fn drop(&mut self)

Executes the destructor for this type.

impl From<&RootedGuard<'_, Vec<Value>>> for HandleValueArray

fn from(vec: &RootedGuard<'_, Vec<JSVal>>) -> HandleValueArray

Converts to this type from the input type.

impl<'a, const N: usize> From<&RootedGuard<'a, ValueArray<N>>> for HandleValueArray

fn from(array: &RootedGuard<'a, ValueArray<N>>) -> HandleValueArray

Converts to this type from the input type.