Struct gluon_vm::api::Opaque

pub struct Opaque<T, V>(_, _)
 where
    V: ?Sized;

Type implementing both Pushable and Getable of values of V regardless of wheter V implements the traits. The actual value, V is only accessible directly either by Deref if it is Userdata or a string or by the to_value method if it implements Getable.

When the value is not accessible the value can only be transferred back into gluon again without inspecting the value itself two different threads.

Methods

impl<'vm, V> Opaque<RootedValue<T>, V> where
    V: ?Sized, 

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

impl<T, V> Opaque<RootedValue<T>, V> where
    T: VmRootInternal,
    V: ?Sized, 

pub fn vm(&self) -> &Thread

pub fn to_value<'vm>(&'vm self) -> V where
    V: Getable<'vm, 'vm>, 

Converts the value into its Rust representation

impl<T, V> Opaque<T, V> where
    V: ?Sized, 

pub fn from_value(value: T) -> Self

pub fn into_inner(self) -> T

impl<'s, 'value, T, V> Opaque<T, V> where
    T: AsVariant<'s, 'value>,
    V: ?Sized, 

pub fn get_value(&'s self) -> &'s Value

pub fn get_variant(&'s self) -> Variants<'value>

pub fn get_ref(&'s self) -> ValueRef<'value>

impl<'s, 'value, T, V> Opaque<T, [V]> where
    T: AsVariant<'s, 'value>, 

pub fn len(&'s self) -> usize

pub fn get_array(&'s self) -> GcRef<'value, ValueArray>

pub fn get(&'s self, index: VmInt) -> Option<OpaqueRef<'value, V>>

pub fn iter(&'s self) -> Iter<'s, 'value, T, V>

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

pub fn get2<'value>(&'value self, index: VmInt) -> Option<V> where
    V: for<'vm> Getable<'vm, 'value>, 

Trait Implementations

impl<T, V> AsRef<V> for Opaque<T, V> where
    V: ?Sized,
    Self: Deref<Target = V>, 

fn as_ref(&self) -> &V

Performs the conversion.

impl<T, V> Borrow<V> for Opaque<T, V> where
    V: ?Sized,
    Self: Deref<Target = V>, 

fn borrow(&self) -> &V

Immutably borrows from an owned value.

impl<T, V> Clone for Opaque<T, V> where
    T: 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, V> Debug for Opaque<T, V> where
    T: Debug, 

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

Formats the value using the given formatter.

impl<T, V> Deref for Opaque<T, V> where
    T: AsValueRef,
    V: Userdata, 

type Target = V

The resulting type after dereferencing.

fn deref(&self) -> &V

Dereferences the value.

impl<'s, 'value, T> Deref for Opaque<T, GcPtr<ClosureData>> where
    T: AsVariant<'s, 'value>, 

type Target = GcPtr<ClosureData>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T, V> Deref for Opaque<T, [V]> where
    T: AsValueRef,
    V: ArrayRepr + Copy, 

type Target = [V]

The resulting type after dereferencing.

fn deref(&self) -> &[V]

Dereferences the value.

impl<T> Deref for Opaque<T, str> where
    T: AsValueRef, 

type Target = str

The resulting type after dereferencing.

fn deref(&self) -> &str

Dereferences the value.

impl<T, V: ?Sized> Eq for Opaque<T, V> where
    T: AsValueRef,
    Self: Borrow<V>,
    V: Eq, 

impl<'vm, 'value, V> Getable<'vm, 'value> for Opaque<Variants<'value>, V> where
    V: ?Sized, 

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<'a, T, V> IntoIterator for &'a Opaque<T, [V]> where
    T: AsVariant<'a, 'a>, 

type Item = OpaqueRef<'a, V>

The type of the elements being iterated over.

type IntoIter = Iter<'a, 'a, T, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, V: ?Sized> Ord for Opaque<T, V> where
    T: AsValueRef,
    Self: Borrow<V>,
    V: Ord, 

fn cmp(&self, other: &Self) -> Ordering

This method returns an [Ordering] between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl<T, V: ?Sized> PartialEq<Opaque<T, V>> for Opaque<T, V> where
    T: AsValueRef,
    Self: Borrow<V>,
    V: PartialEq, 

fn eq(&self, other: &Self) -> 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, V: ?Sized> PartialOrd<Opaque<T, V>> for Opaque<T, V> where
    T: AsValueRef,
    Self: Borrow<V>,
    V: PartialOrd, 

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'s, 'value, 'vm, T, V> Pushable<'vm> for Opaque<T, V> where
    T: Pushable<'vm>,
    V: ?Sized, 

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> Serialize for Opaque<T, str> where
    T: AsValueRef, 

fn serialize<S>(&self, serializer: S) -> StdResult<S::Ok, S::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.

impl<T> SerializeState<Thread> for Opaque<T, str> where
    T: AsValueRef, 

fn serialize_state<S>(
    &self,
    serializer: S,
    _thread: &Thread
) -> StdResult<S::Ok, S::Error> where
    S: Serializer, 

Serializes self

impl<T, V> Trace for Opaque<T, V> where
    T: Trace, 

unsafe fn root(&mut self)

unsafe fn unroot(&mut self)

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

impl<T, V: ?Sized> VmType for Opaque<T, V> where
    V: VmType,
    V::Type: Sized, 

type Type = V::Type

A version of Self which implements Any allowing a TypeId to be retrieved

fn make_type(vm: &Thread) -> ArcType

Creates an gluon type which maps to Self in rust

fn extra_args() -> VmIndex

How many extra arguments a function returning this type requires. Used for abstract types which when used in return position should act like they still need more arguments before they are called

fn make_forall_type(vm: &Thread) -> ArcType