Struct gluon_vm::thread::RootedValue

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

A rooted value

Implementations

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>

pub fn into_owned(self) -> RootedValue<RootedThread>

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 ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'vm, T> Pushable<'vm> for RootedValue<T>

where T: VmRootInternal,

fn vm_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)