Struct gluon_vm::thread::RootedValue

pub struct RootedValue<T> where
    T: Deref<Target = Thread>,  { /* fields omitted */ }

A rooted value

Methods

impl<T> RootedValue<T> where
    T: Deref<Target = Thread>, 

pub fn re_root<'vm, U>(&self, vm: U) -> Result<RootedValue<U>> where
    U: VmRoot<'vm>, 

pub fn get_variant(&self) -> Variants

pub fn get_value(&self) -> Value

pub fn vm(&self) -> &Thread

pub fn clone_vm(&self) -> T where
    T: Clone, 

pub fn get<'vm>(&'vm self, index: usize) -> Option<RootedValue<T>> where
    T: VmRoot<'vm>, 

looks up the field at the given offset

pub fn get_field<'vm>(&'vm self, name: &str) -> Option<RootedValue<T>> where
    T: VmRoot<'vm>, 

looks up the record field with the given name

pub fn as_ref(&self) -> RootedValue<&Thread>

impl<'vm> RootedValue<&'vm Thread>

pub fn vm_(&self) -> &'vm Thread

Trait Implementations

impl<'vm, T> Pushable<'vm> for RootedValue<T> where
    T: Deref<Target = Thread>, 

fn push(self, context: &mut ActiveThread<'vm>) -> Result<()>

Pushes self to stack. If the call is successful a single element should have been added to the stack and Ok(()) should be returned. If the call is unsuccessful Status:Error should be returned and the stack should be left intact

fn status_push(self, context: &mut ActiveThread<'vm>) -> Status where
    Self: Sized, 

unsafe fn marshal_unrooted(self, vm: &'vm Thread) -> Result<Value> where
    Self: Sized, 

fn marshal<T>(self, vm: &'vm Thread) -> Result<RootedValue<T>> where
    Self: Sized,
    T: VmRoot<'vm>, 

impl<'vm, 'value, T> Getable<'vm, 'value> for RootedValue<T> where
    T: Deref<Target = Thread> + VmRoot<'vm>, 

fn from_value(vm: &'vm Thread, value: Variants<'value>) -> Self

impl<T> Clone for RootedValue<T> where
    T: Deref<Target = Thread> + Clone, 

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Drop for RootedValue<T> where
    T: Deref<Target = Thread>, 

fn drop(&mut self)

Executes the destructor for this type.

impl<T, U> PartialEq<RootedValue<U>> for RootedValue<T> where
    T: Deref<Target = Thread>,
    U: Deref<Target = Thread>, 

fn eq(&self, other: &RootedValue<U>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T> Debug for RootedValue<T> where
    T: Deref<Target = Thread>, 

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.