Struct CurrentRealm 

pub(crate) struct CurrentRealm<'cx> {
    cx: &'cx mut JSContext,
    realm: NonNull<Realm>,
}

Represents the current realm of JSContext (top realm on realm stack).

Similarly to AutoRealm, while you can access this type via &mut/&mut we know that this realm is current (on top of realm stack).

use mozjs::context::JSContext;
use mozjs::jsapi::JSObject;
use mozjs::realm::{AutoRealm, CurrentRealm};
use std::ptr::NonNull;

fn f(current_realm: &mut CurrentRealm, target: NonNull<JSObject>) {
    let mut realm = AutoRealm::new(current_realm, target);
    let cx: &mut JSContext = &mut *current_realm; // we cannot use current realm while it's not current
}

Fields

cx: &'cx mut JSContext

realm: NonNull<Realm>

Implementations

impl<'cx> CurrentRealm<'cx>

pub fn assert(cx: &'cx mut JSContext) -> CurrentRealm<'cx>

Asserts that the current realm is valid and returns it.

pub fn global(&self) -> Handle<'_, *mut JSObject>

Obtain the handle to the global object of the this realm. Because the handle is bounded with lifetime to realm, you cannot do this:

use mozjs::context::JSContext;
use mozjs::jsapi::JSObject;
use mozjs::realm::CurrentRealm;
use std::ptr::NonNull;
use mozjs::rust::Handle;

fn g(realm: &'_ mut CurrentRealm, global: Handle<'_, *mut JSObject>) {
}

fn f(realm: &mut CurrentRealm) {
    let global = realm.global();
    g(realm, global);
}

instead use CurrentRealm::global_and_reborrow.

pub fn global_and_reborrow( &mut self, ) -> (Handle<'_, *mut JSObject>, &mut CurrentRealm<'cx>)

Obtain the handle to the global object of this realm and reborrow the realm.

use mozjs::context::JSContext;
use mozjs::jsapi::JSObject;
use mozjs::realm::CurrentRealm;
use std::ptr::NonNull;
use mozjs::rust::Handle;

fn g(realm: &'_ mut CurrentRealm, global: Handle<'_, *mut JSObject>) {
}

fn f(realm: &mut CurrentRealm) {
    let (global, realm) = realm.global_and_reborrow();
    g(realm, global);
}

pub fn realm(&self) -> &NonNull<Realm>

Methods from Deref<Target = JSContext>

pub fn no_gc<'cx>(&'cx self) -> &'cx NoGC<'cx>

Returns NoGC token bounded to this JSContext. No function that accepts &mut JSContext (read: triggers GC) can be called while this is alive.

pub unsafe fn raw_cx(&mut self) -> *mut JSContext

Obtain RawJSContext mutable pointer.

Safety

No NoGC tokens should be constructed while returned pointer is available to user. In practices this means that one should use the result as direct argument to SpiderMonkey function and not store it in variable.

use mozjs::context::*;
use mozjs::jsapi::JSContext as RawJSContext;

fn SM_function_that_can_trigger_gc(_cx: *mut RawJSContext) {}

fn can_trigger_gc(cx: &mut JSContext) {
    unsafe { SM_function_that_can_trigger_gc(cx.raw_cx()) } // returned pointer is immediately used
    cx.no_gc(); // this is ok because no outstanding raw pointer is alive
}

pub unsafe fn raw_cx_no_gc(&self) -> *mut JSContext

Obtain RawJSContext mutable pointer, that will not be used for GC.

Safety

No &mut calls should be done on JSContext while returned pointer is available. In practices this means that one should use the result as direct argument to SpiderMonkey function and not store it in variable.

use mozjs::context::*;
use mozjs::jsapi::JSContext as RawJSContext;

fn SM_function_that_cannot_trigger_gc(_cx: *mut RawJSContext) {}

fn f(cx: &mut JSContext) {
    unsafe { SM_function_that_cannot_trigger_gc(cx.raw_cx_no_gc()) } // returned pointer is immediately used
}

Trait Implementations

impl<'cx> Deref for CurrentRealm<'cx>

type Target = JSContext

The resulting type after dereferencing.

fn deref(&self) -> &<CurrentRealm<'cx> as Deref>::Target

Dereferences the value.

impl<'cx> DerefMut for CurrentRealm<'cx>

fn deref_mut(&mut self) -> &mut <CurrentRealm<'cx> as Deref>::Target

Mutably dereferences the value.

impl<'a, 'b> From<&'a mut CurrentRealm<'b>> for AlreadyInRealm

fn from(_: &'a mut CurrentRealm<'b>) -> AlreadyInRealm

Converts to this type from the input type.