Struct artichoke::prelude::Guard

pub struct Guard<'a>(/* private fields */);

Interpreter guard that prepares an Artichoke to re-enter an FFI boundary.

Artichoke integrates with the mruby VM via many extern "C" fn trampolines that are invoked by mruby to run some portion of the VM in Rust.

These trampolines typically require an Artichoke interpreter to do useful work, so they move the State out of the mrb userdata pointer into an Artichoke struct.

To ensure safety, the State must be moved back into the mrb userdata pointer before re-entering the FFI boundary. This guard implements Drop to re-serialize the State into the mrb once it goes out of scope.

Guard is passed directly to error::raise.

Implementations

impl<'a> Guard<'a>

pub fn new(interp: &'a mut Artichoke) -> Guard<'a>

Create a new guard that wraps an interpreter.

This function is most effective when the interpreter is temporarily created from a source mrb_state and stored on the stack.

pub fn interp(&mut self) -> &mut Artichoke

Access the inner guarded interpreter.

The interpreter is also accessible via Deref, DerefMut, AsRef, and AsMut.

Methods from Deref<Target = Artichoke>

pub fn protect(&mut self, value: Value) -> Value

Prevent the given value from being garbage collected.

Calls sys::mrb_gc_protect on this value which adds it to the GC arena. This object will remain in the arena until ArenaIndex::restore restores the arena to an index before this call to protect.

pub unsafe fn with_ffi_boundary<F, T>( &mut self, func: F ) -> Result<T, InterpreterExtractError>

where F: FnOnce(*mut mrb_state) -> T,

Execute a a closure by moving the State into the mrb instance.

This method prepares this interpreter to cross an FFI boundary. When the Artichoke implementation calls mruby FFI functions, the State must be moved into the sys::mrb_state userdata pointer.

Safety

This method moves the State out of this instance into the mrb instance. During this function’s execution, this instance may be partially initialized.

This function is only safe to call if the closure only calls FFI functions that use a raw *mut sys::mrb_state.

pub fn lookup_symbol_with_trailing_nul( &self, symbol: u32 ) -> Result<Option<&[u8]>, Error>

pub fn intern_bytes_with_trailing_nul<T>( &mut self, bytes: T ) -> Result<u32, Error>

where T: Into<Cow<'static, [u8]>>,

pub fn check_interned_bytes_with_trailing_nul( &self, bytes: &[u8] ) -> Result<Option<u32>, Error>

Trait Implementations

impl<'a> Debug for Guard<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'a> Deref for Guard<'a>

type Target = Artichoke

The resulting type after dereferencing.

fn deref(&self) -> &<Guard<'a> as Deref>::Target

Dereferences the value.

impl<'a> DerefMut for Guard<'a>

fn deref_mut(&mut self) -> &mut <Guard<'a> as Deref>::Target

Mutably dereferences the value.

impl<'a> Drop for Guard<'a>

fn drop(&mut self)

Executes the destructor for this type.