Struct gluon_vm::thread::Context

pub struct Context { /* fields omitted */ }

Implementations

impl Context

pub fn push_new_data(
    &mut self,
    thread: &Thread,
    tag: VmTag,
    fields: usize
) -> Result<Variants<'_>>

pub fn push_new_record(
    &mut self,
    thread: &Thread,
    fields: usize,
    field_names: &[InternedStr]
) -> Result<Variants<'_>>

pub fn alloc_with<D>(
    &mut self,
    thread: &Thread,
    data: D
) -> Result<GcRef<'_, D::Value>> where
    D: DataDef + Trace,
    D::Value: Sized + Any, 

pub fn alloc_ignore_limit<D>(&mut self, data: D) -> GcRef<'_, D::Value> where
    D: DataDef + Trace,
    D::Value: Sized + Any, 

pub fn set_hook(&mut self, hook: Option<HookFn>) -> Option<HookFn>

pub fn set_hook_mask(&mut self, flags: HookFlags)

pub fn set_max_stack_size(&mut self, limit: VmIndex)

pub fn stacktrace(&self, frame_level: usize) -> Stacktrace

pub unsafe fn return_future<'vm, F>(
    &mut self,
    future: F,
    lock: Lock,
    frame_index: VmIndex
) where
    F: Future + Send + 'vm,
    F::Output: Pushable<'vm>, 

“Returns a future”, letting the virtual machine know that future must be resolved to produce the actual value.

Safety

This function is unsafe because the vm lifetime must not outlive the lifetime of the Thread

Trait Implementations

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

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 SerializeState<SeSeed> for Context

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

Serializes self