Struct ezlua::prelude::Coroutine

pub struct Coroutine { /* private fields */ }

Implementations

impl Coroutine

pub fn empty(s: &State) -> Self

pub fn new(fun: ValRef<'_>) -> Result<Self>

pub fn resume<'a, A: ToLuaMulti, R: FromLuaMulti<'a>>( &'a mut self, args: A ) -> Result<R>

Methods from Deref<Target = State>

pub unsafe fn new_iter<'l, R: ToLuaMulti + 'l, I: Iterator<Item = R> + 'l, REF: ToLua, const C: usize>( &self, iter: I, refs: [REF; C] ) -> Result<Function<'_>>

Create an iterator with non-static reference, you should ensure that these references is valid via the refs argument, which is be referenced by the iter closure’s upvalues

pub unsafe fn new_iter_map<'l, R: 'l, I: Iterator<Item = R> + 'l, MR: ToLuaMulti + 'l, M: Fn(&'l State, R) -> MR, REF: ToLua, const C: usize>( &'l self, iter: I, map: M, refs: [REF; C] ) -> Result<Function<'_>>

Like State::new_iter, and you can specify a map function

pub fn new_function<'l, ARGS: FromLuaMulti<'l>, RET: ToLuaMulti + 'l, F: Fn(&'l State, ARGS) -> RET + 'static>( &self, fun: F ) -> Result<Function<'_>>

Bind a rust function(closure) with uniform argument types

pub fn new_closure<'l, A: 'l, R: 'l, F: LuaMethod<'l, (), A, R> + 'static>( &self, fun: F ) -> Result<Function<'_>>

Bind a rust function(closure) with flexible argument types

pub fn new_closure0<'l, RET: ToLuaMulti + 'l, FN: Fn(&'l State) -> RET + 'static>( &'l self, f: FN ) -> Result<Function<'l>>

pub fn new_closure1<'l, RET: ToLuaMulti + 'l, A: FromLua<'l>, FN: Fn(&'l State, A) -> RET + 'static>( &'l self, f: FN ) -> Result<Function<'l>>

pub fn new_closure2<'l, RET: ToLuaMulti + 'l, A: FromLua<'l>, B: FromLua<'l>, FN: Fn(&'l State, A, B) -> RET + 'static>( &'l self, f: FN ) -> Result<Function<'l>>

pub fn new_closure3<'l, RET: ToLuaMulti + 'l, A: FromLua<'l>, B: FromLua<'l>, C: FromLua<'l>, FN: Fn(&'l State, A, B, C) -> RET + 'static>( &'l self, f: FN ) -> Result<Function<'l>>

pub fn new_closure4<'l, RET: ToLuaMulti + 'l, A: FromLua<'l>, B: FromLua<'l>, C: FromLua<'l>, D: FromLua<'l>, FN: Fn(&'l State, A, B, C, D) -> RET + 'static>( &'l self, f: FN ) -> Result<Function<'l>>

pub fn new_closure5<'l, RET: ToLuaMulti + 'l, A: FromLua<'l>, B: FromLua<'l>, C: FromLua<'l>, D: FromLua<'l>, E: FromLua<'l>, FN: Fn(&'l State, A, B, C, D, E) -> RET + 'static>( &'l self, f: FN ) -> Result<Function<'l>>

pub fn new_closure6<'l, RET: ToLuaMulti + 'l, A: FromLua<'l>, B: FromLua<'l>, C: FromLua<'l>, D: FromLua<'l>, E: FromLua<'l>, F: FromLua<'l>, FN: Fn(&'l State, A, B, C, D, E, F) -> RET + 'static>( &'l self, f: FN ) -> Result<Function<'l>>

pub fn new_closure7<'l, RET: ToLuaMulti + 'l, A: FromLua<'l>, B: FromLua<'l>, C: FromLua<'l>, D: FromLua<'l>, E: FromLua<'l>, F: FromLua<'l>, G: FromLua<'l>, FN: Fn(&'l State, A, B, C, D, E, F, G) -> RET + 'static>( &'l self, f: FN ) -> Result<Function<'l>>

pub fn new_closure8<'l, RET: ToLuaMulti + 'l, A: FromLua<'l>, B: FromLua<'l>, C: FromLua<'l>, D: FromLua<'l>, E: FromLua<'l>, F: FromLua<'l>, G: FromLua<'l>, H: FromLua<'l>, FN: Fn(&'l State, A, B, C, D, E, F, G, H) -> RET + 'static>( &'l self, f: FN ) -> Result<Function<'l>>

pub fn new_closure9<'l, RET: ToLuaMulti + 'l, A: FromLua<'l>, B: FromLua<'l>, C: FromLua<'l>, D: FromLua<'l>, E: FromLua<'l>, F: FromLua<'l>, G: FromLua<'l>, H: FromLua<'l>, I: FromLua<'l>, FN: Fn(&'l State, A, B, C, D, E, F, G, H, I) -> RET + 'static>( &'l self, f: FN ) -> Result<Function<'l>>

pub fn new_closure10<'l, RET: ToLuaMulti + 'l, A: FromLua<'l>, B: FromLua<'l>, C: FromLua<'l>, D: FromLua<'l>, E: FromLua<'l>, F: FromLua<'l>, G: FromLua<'l>, H: FromLua<'l>, I: FromLua<'l>, J: FromLua<'l>, FN: Fn(&'l State, A, B, C, D, E, F, G, H, I, J) -> RET + 'static>( &'l self, f: FN ) -> Result<Function<'l>>

pub fn pushed<T: ToLuaMulti>(&self, results: T) -> Result<Pushed>

Push results to stack

pub fn serialize_to_val<V: Serialize>(&self, v: V) -> LuaResult<ValRef<'_>>

convert a serializable value into a lua value

pub fn load_from_deserializer<'de, D: Deserializer<'de>>( &'de self, deserializer: D ) -> Result<ValRef<'de>, LuaError>

transcode a serializable value from deserializer into a lua value

pub fn array_metatable(&self) -> LuaResult<LuaTable<'_>>

A metatable attachable to a Lua table to systematically encode it as Array (instead of Map). As result, encoded Array will contain only sequence part of the table, with the same length as the # operator on that table.

pub fn null_value(&self) -> LuaValue<'_>

A special value to encode/decode optional (none) values.

pub fn register_usertype<U: UserData>(&self) -> Result<Table<'_>>

Register a metatable of UserData into the C registry and return it

pub fn new_userdata<T: UserData>(&self, data: T) -> Result<LuaUserData<'_>>

Create userdata

pub fn new_userdata_with_values<T: UserData, R: ToLua, const N: usize>( &self, data: T, refs: [R; N] ) -> Result<LuaUserData<'_>>

pub fn raw_state(&self) -> *mut lua_State

pub fn stack_top(&self) -> i32

pub fn check_stack(&self, n: i32) -> Result<()>

pub fn check_type(&self, i: Index, ty: Type) -> Result<()>

pub fn up_value(&self, i: Index) -> ValRef<'_>

pub fn arg_val(&self, i: Index) -> Option<ValRef<'_>>

pub fn to_safe_bytes(&self, i: Index) -> Option<&[u8]>

pub fn registry(&self) -> Table<'_>

Get the C registry table

pub fn new_val<V: ToLua>(&self, val: V) -> Result<ValRef<'_>>

Create a new lua value

pub fn new_value<V: ToLua>(&self, val: V) -> Result<Value<'_>>

Create a new lua value, return as Value rather than ValRef

pub fn new_table_with_size(&self, narr: c_int, nrec: c_int) -> Result<Table<'_>>

Create a lua table and specify the size

pub fn new_table(&self) -> Result<Table<'_>>

Create a lua table

pub fn new_string<S: AsRef<[u8]>>(&self, s: S) -> Result<LuaString<'_>>

Create a lua string

pub fn load<S: AsRef<[u8]>>( &self, s: S, name: Option<&str> ) -> Result<Function<'_>>

Load script string or bytecode

pub fn load_file<P: AsRef<Path>>(&self, path: P) -> Result<Function<'_>>

Create function from script file

pub fn register_module<'a, F: Fn(&'a State) -> Result<Table<'a>>>( &self, name: &str, init: F, global: bool ) -> Result<()>

Register your own lua module, which can be load by require function in lua

pub fn global(&self) -> Table<'_>

Get the lua global table

pub fn gc_collect(&self) -> Result<()>

Do a full GC for lua

pub fn backtrace( &self, co: Option<&State>, msg: &str, level: i32 ) -> Result<String>

Stack backtrace info

pub unsafe fn test_userdata_meta<T>( &self, i: Index, meta: MetatableKey ) -> Option<&mut T>

pub fn stack(&self, n: i32) -> Option<lua_Debug>

pub fn do_string<S: AsRef<[u8]>>( &self, script: S, name: Option<&str> ) -> Result<()>

Load lua script and execute it

pub fn registry_value<V: ToLua>(&self, val: V) -> Result<RegVal>

pub fn safe_index(&self, i: Index) -> bool

pub fn free_slots(&self) -> Ref<'_, Slots<i32>>

Trait Implementations

impl Deref for Coroutine

type Target = State

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Drop for Coroutine

fn drop(&mut self)

Executes the destructor for this type.

impl FromLua<'_> for Coroutine

fn from_lua(s: &State, val: ValRef<'_>) -> Result<Self>

const TYPE_NAME: &'static str = _

impl Send for Coroutine