Trait gluon_vm::thread::ThreadInternal[−][src]

pub trait ThreadInternal where
    &'a Self: Deref<Target = Thread>, {
    fn context(&self) -> OwnedContext;

    fn root<'vm, T: Userdata>(
        &'vm self, 
        v: GcPtr<Box<Userdata>>
    ) -> Option<Root<'vm, T>>;

    fn root_string<'vm>(&'vm self, ptr: GcStr) -> RootStr<'vm>;

    fn root_value<'vm, T>(&'vm self, value: Value) -> RootedValue<T>
    where
        T: VmRoot<'vm>;

    fn call_thunk(
        &self, 
        closure: GcPtr<ClosureData>
    ) -> FutureValue<Execute<&Self>>;

    fn execute_io(&self, value: Value) -> FutureValue<Execute<&Self>>;

    fn call_function<'b>(
        &'b self, 
        stack: OwnedContext<'b>, 
        args: VmIndex
    ) -> Result<Async<Option<OwnedContext<'b>>>>;

    fn resume(&self) -> Result<Async<OwnedContext>>;

    fn global_env(&self) -> &Arc<GlobalVmState>;

    fn set_global(
        &self, 
        name: Symbol, 
        typ: ArcType, 
        metadata: Metadata, 
        value: Value
    ) -> Result<()>;

    fn deep_clone_value(&self, owner: &Thread, value: Value) -> Result<Value>;

    fn can_share_values_with(&self, gc: &mut Gc, other: &Thread) -> bool;
}

Internal functions for interacting with threads. These functions should be considered both unsafe and unstable.

Required Methods

Locks and retrives this threads stack

Roots a userdata

Roots a string

Roots a value

Evaluates a zero argument function (a thunk)

Executes an IO action

Calls a function on the stack. When this function is called it is expected that the function exists at stack.len() - args - 1 and that the arguments are of the correct type

owner is theread that owns value which is not necessarily the same as self

Implementors