Struct gluon_vm::thread::RootedValue

pub struct RootedValue<T> where
    T: VmRootInternal,  { /* fields omitted */ }

A rooted value

Methods

impl<T> RootedValue<T> where
    T: VmRootInternal, 

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

pub fn get_value(&self) -> &Value

pub fn get_variant(&self) -> Variants

pub fn vm(&self) -> &T

pub fn vm_mut(&mut self) -> &mut T

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

Methods from Deref<Target = Value>

pub fn get_variants(&self) -> Variants

pub fn generation(&self) -> Generation

pub fn obj_eq(&self, other: &Self) -> bool

Trait Implementations

impl<T> Clone for RootedValue<T> where
    T: VmRootInternal + 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> Debug for RootedValue<T> where
    T: VmRootInternal, 

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

Formats the value using the given formatter.

impl<T> Deref for RootedValue<T> where
    T: VmRootInternal, 

type Target = Value

The resulting type after dereferencing.

fn deref(&self) -> &Value

Dereferences the value.

impl<'de> Deserialize<'de> for RootedValue<RootedThread>

fn deserialize<D>(deserializer: D) -> StdResult<Self, D::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<'de, 'gc> DeserializeState<'de, DeSeed<'gc>> for RootedValue<RootedThread>

fn deserialize_state<D>(
    seed: &mut DeSeed<'gc>,
    deserializer: D
) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

Deserializes Self using seed and the deserializer

impl<T> Drop for RootedValue<T> where
    T: VmRootInternal, 

fn drop(&mut self)

Executes the destructor for this type.

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

type Proxy = Variants<'value>

fn to_proxy(_vm: &'vm Thread, value: Variants<'value>) -> Result<Self::Proxy>

fn from_proxy(vm: &'vm Thread, proxy: &'value mut Self::Proxy) -> Self

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

impl<T, U> PartialEq<RootedValue<U>> for RootedValue<T> where
    T: VmRootInternal,
    U: VmRootInternal, 

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<'vm, T> Pushable<'vm> for RootedValue<T> where
    T: VmRootInternal, 

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<T> Trace for RootedValue<T> where
    T: VmRootInternal, 

unsafe fn root(&mut self)

unsafe fn unroot(&mut self)

fn trace(&self, gc: &mut Gc)