Struct Thread

pub struct Thread<'lua>(/* private fields */);

Handle to an internal Lua thread (coroutine).

Implementations

impl<'lua> Thread<'lua>

pub fn resume<A, R>(&self, args: A) -> Result<R>

where A: IntoLuaMulti<'lua>, R: FromLuaMulti<'lua>,

Resumes execution of this thread.

Equivalent to coroutine.resume.

Passes args as arguments to the thread. If the coroutine has called coroutine.yield, it will return these arguments. Otherwise, the coroutine wasn’t yet started, so the arguments are passed to its main function.

If the thread is no longer in Active state (meaning it has finished execution or encountered an error), this will return Err(CoroutineInactive), otherwise will return Ok as follows:

If the thread calls coroutine.yield, returns the values passed to yield. If the thread returns values from its main function, returns those.

Examples

let thread: Thread = lua.load(r#"
    coroutine.create(function(arg)
        assert(arg == 42)
        local yieldarg = coroutine.yield(123)
        assert(yieldarg == 43)
        return 987
    end)
"#).eval()?;

assert_eq!(thread.resume::<_, u32>(42)?, 123);
assert_eq!(thread.resume::<_, u32>(43)?, 987);

// The coroutine has now returned, so `resume` will fail
match thread.resume::<_, u32>(()) {
    Err(Error::CoroutineInactive) => {},
    unexpected => panic!("unexpected result {:?}", unexpected),
}

pub fn status(&self) -> ThreadStatus

Gets the status of the thread.

pub fn set_hook<F>(&self, triggers: HookTriggers, callback: F)

where F: Fn(&Lua, Debug<'_>) -> Result<()> + MaybeSend + 'static,

Sets a ‘hook’ function that will periodically be called as Lua code executes.

This function is similar or Lua::set_hook() except that it sets for the thread. To remove a hook call Lua::remove_hook().

pub fn to_pointer(&self) -> *const c_void

Converts this thread to a generic C pointer.

There is no way to convert the pointer back to its original value.

Typically this function is used only for hashing and debug information.

Trait Implementations

impl<'lua> Clone for Thread<'lua>

fn clone(&self) -> Thread<'lua>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'lua> Debug for Thread<'lua>

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

Formats the value using the given formatter.

impl<'lua> FromLua<'lua> for Thread<'lua>

fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Thread<'lua>>

Performs the conversion.

impl<'lua> IntoLua<'lua> for &Thread<'lua>

fn into_lua(self, _: &'lua Lua) -> Result<Value<'lua>>

Performs the conversion.

impl<'lua> IntoLua<'lua> for Thread<'lua>

fn into_lua(self, _: &'lua Lua) -> Result<Value<'lua>>

Performs the conversion.

impl<'lua> PartialEq for Thread<'lua>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.