Struct gluon::RootedThread

pub struct RootedThread(_);

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

Methods

impl RootedThread

fn new() -> RootedThread

Creates a new virtual machine with an empty global environment

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

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>

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

fn root_thread(&self) -> RootedThread

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

fn define_global<'vm, T>(&'vm self, name: &str, value: T) -> Result<(), Error> where
    T: Pushable<'vm> + VmType, 

Creates a new global value at name. Fails if a global called name already exists.

fn get_global<'vm, T>(&'vm self, name: &str) -> Result<T, Error> where
    T: Getable<'vm> + VmType, 

Retrieves the global called name. Fails if the global does not exist or it does not have the correct type.

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

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

fn get_type<T>(&self) -> ArcType<Symbol> where
    T: Any + ?Sized, 

Returns the gluon type that was bound to T

fn register_type<T>(
    &self,
    name: &str,
    args: &[&str]
) -> Result<ArcType<Symbol>, Error> where
    T: Any + ?Sized, 

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

fn get_env(&'b self) -> RwLockReadGuard<'b, VmEnv>

Locks and retrieves the global environment of the vm

fn get_macros(&self) -> &MacroEnv

Retrieves the macros defined for this vm

fn collect(&self)

Runs a garbage collection.

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

Pushes a value to the top of the stack

fn pop(&self)

Removes the top value from the stack

fn set_memory_limit(&self, memory_limit: usize)

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<'vm> Pushable<'vm> for RootedThread

fn push(self, _vm: &'vm Thread, context: &mut Context) -> Result<(), Error>

impl Debug for RootedThread

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

Formats the value using the given formatter.

impl Deref for RootedThread

type Target = Thread

fn deref(&self) -> &Thread

impl Drop for RootedThread

fn drop(&mut self)

impl Traverseable for RootedThread

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

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

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

impl VmType for RootedThread

type Type = Thread

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

fn make_type(vm: &Thread) -> ArcType<Symbol>

Creates an gluon type which maps to Self in rust

fn extra_args() -> u32

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