Struct gluon::RootedThread

pub struct RootedThread { /* private fields */ }

An instance of Thread which is rooted. See the Thread type for documentation on interacting with the type.

Implementations

impl RootedThread

pub fn new() -> RootedThread

Creates a new virtual machine with an empty global environment

pub fn with_global_state(global_state: GlobalVmState) -> RootedThread

pub fn into_raw(self) -> *const Thread

Converts a RootedThread into a raw pointer allowing to be passed through a C api. The reference count for the thread is not modified

pub unsafe fn from_raw(ptr: *const Thread) -> RootedThread

Converts a raw pointer into a RootedThread. The reference count for the thread is not modified so it is up to the caller to ensure that the count is correct.

Methods from Deref<Target = Thread>

pub fn new_thread(&self) -> Result<RootedThread, Error>

Spawns a new gluon thread with its own stack and heap but while still sharing the same global environment

pub fn root_thread(&self) -> RootedThread

Roots self, extending the lifetime of this thread until at least the returned RootedThread is droppped

pub fn spawner(&self) -> Option<&(dyn Spawn + Send + Sync)>

pub fn get_global<'vm, T>(&'vm self, name: &str) -> Result<T, Error>

where T: for<'value> Getable<'vm, 'value> + VmType,

Retrieves the global called name.

Examples

Bind the (+) function in gluon’s prelude standard library to an add function in rust

let vm = new_vm_async().await;

vm.run_expr_async::<OpaqueValue<&Thread, Hole>>("example", r#" import! std.int "#)
    .await
    .unwrap_or_else(|err| panic!("{}", err));
let mut add: FunctionRef<fn(i32, i32) -> i32> =
    vm.get_global("std.int.num.(+)").unwrap();
let result = add.call_async(1, 2).await;
assert_eq!(result, Ok(3));

Errors

if the global does not exist or it does not have the correct type.

pub fn get_global_type(&self, name: &str) -> Result<ArcType, Error>

pub fn find_type_info( &self, name: &str ) -> Result<Alias<Symbol, ArcType>, Error>

Retrieves type information about the type name. Types inside records can be accessed using dot notation (std.prelude.Option)

pub fn get_type<T>(&self) -> Option<ArcType>

where T: Any + ?Sized,

Returns the gluon type that was bound to T

pub fn register_type<T>( &self, name: &str, args: &[&str] ) -> Result<ArcType, Error>

where T: Any + ?Sized,

Registers the type T as being a gluon type called name with generic arguments args

pub fn register_type_as( &self, name: Symbol, alias: Alias<Symbol, ArcType>, id: TypeId ) -> Result<ArcType, Error>

pub fn get_cache_alias(&self, name: &str) -> Option<ArcType>

pub fn cache_alias(&self, alias: Alias<Symbol, ArcType>) -> ArcType

pub fn get_env<'b>(&'b self) -> VmEnvInstance<'b>

Locks and retrieves the global environment of the vm

pub fn get_macros(&self) -> &MacroEnv

Retrieves the macros defined for this vm

pub fn collect(&self)

Runs a garbage collection.

pub fn push<'vm, T>(&'vm self, v: T) -> Result<(), Error>

where T: Pushable<'vm>,

Pushes a value to the top of the stack

pub fn pop(&self)

Removes the top value from the stack

pub fn allocated_memory(&self) -> usize

pub fn set_memory_limit(&self, memory_limit: usize)

pub fn interrupt(&self)

pub fn interrupted(&self) -> bool

pub fn current_context(&self) -> ActiveThread<'_>

Trait Implementations

impl Clone for RootedThread

fn clone(&self) -> RootedThread

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RootedThread

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

Formats the value using the given formatter.

impl Deref for RootedThread

type Target = Thread

The resulting type after dereferencing.

fn deref(&self) -> &Thread

Dereferences the value.

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

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

where D: Deserializer<'de>,

Deserializes Self using seed and the deserializer

impl Drop for RootedThread

fn drop(&mut self)

Executes the destructor for this type.

impl<'vm, 'value> Getable<'vm, 'value> for RootedThread

type Proxy = Variants<'value>

fn to_proxy( _vm: &'vm Thread, value: Variants<'value> ) -> Result<<RootedThread as Getable<'vm, 'value>>::Proxy, Error>

fn from_proxy( vm: &'vm Thread, proxy: &'value mut <RootedThread as Getable<'vm, 'value>>::Proxy ) -> RootedThread

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

impl<'vm> Pushable<'vm> for RootedThread

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

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, Error>

where Self: Sized,

fn marshal<T>(self, vm: &'vm Thread) -> Result<RootedValue<T>, Error>

where Self: Sized, T: VmRoot<'vm>,

impl SerializeState<SeSeed> for RootedThread

fn serialize_state<__S>( &self, __serializer: __S, __seed: &SeSeed ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serializes self

impl Trace for RootedThread

unsafe fn root(&mut self)

unsafe fn unroot(&mut self)

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

impl<'a> VmRoot<'a> for RootedThread

fn new_root(thread: &'a Thread) -> RootedThread

impl VmRootInternal for RootedThread

fn root_vm(&mut self)

fn unroot_vm(&mut self)

unsafe fn root_value_with_self(self, value: &Value) -> RootedValue<Self>

where Self: Sized,

Roots a value

impl VmType for RootedThread

type Type = Thread

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

fn make_forall_type(vm: &Thread) -> ArcType

fn make_type(vm: &Thread) -> ArcType

Creates an gluon type which maps to Self in rust

const EXTRA_ARGS: u32 = 0u32

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