Struct LuaFunction

pub struct LuaFunction { /* private fields */ }

Reperesents a callable function on the Lua stack

Functions that can be called may be defined in Lua, Rust, C, or any other language with Lua bindings.

Examples

context.do_string("function double(x) return x * 2 end").unwrap();
let lua_double: LuaFunction = context.push_global("double")
    .get_value(&mut context).unwrap();
let result = lua_double.call_singleret(&mut context, &[&4])
    .and_then(|v| v.get_value(&mut context));
assert_eq!(result, Some(8));

Implementations

impl LuaFunction

pub fn new(i: Index) -> LuaFunction

Create a new LuaFunction given an index

pub fn pcall( &self, context: &mut Context<'_>, args: &[&dyn ToLua], errfunc: Option<&LuaFunction>, nresults: i32, ) -> Result<Vec<LuaGeneric>>

Protected function call, errors return an Err If the function call is successful, returns a list of all return values (with a maximum size nresults)

Errors

Returns an Error if Lua encounters a runtime error while running this function. If an errfunc is given, then the given function will be called with the error message as an argument, and the function should return a new error message. errfunc will not be called if no error was encountered, the error that occured was an out of memeory error, or if another error occurred while running errfunc.

pub fn pcall_multiret( &self, context: &mut Context<'_>, args: &[&dyn ToLua], errfunc: Option<&LuaFunction>, ) -> Result<Vec<LuaGeneric>>

Same as pcall, but returns all return values

pub fn pcall_singleret( &self, context: &mut Context<'_>, args: &[&dyn ToLua], errfunc: Option<&LuaFunction>, ) -> Result<Option<LuaGeneric>>

Same as pcall, but only returns at most one return value.

pub fn pcall_noret( &self, context: &mut Context<'_>, args: &[&dyn ToLua], errfunc: Option<&LuaFunction>, ) -> Result<()>

Same as pcall, but returns nothing.

pub fn call( &self, context: &mut Context<'_>, args: &[&dyn ToLua], nresults: i32, ) -> Vec<LuaGeneric>

Call this function, returns a list of return values (with a maximum size nresults).

Panics

This function will panic if Lua encounters a runtime error. It’s not really a panic, it’s actually a longjmp, but it might as well be a panic.

pub fn call_singleret( &self, context: &mut Context<'_>, args: &[&dyn ToLua], ) -> Option<LuaGeneric>

Same as call, but returns at most one return value.

pub fn call_multiret( &self, context: &mut Context<'_>, args: &[&dyn ToLua], ) -> Vec<LuaGeneric>

Same as call, but returns all return values.

pub fn call_noret(&self, context: &mut Context<'_>, args: &[&dyn ToLua])

Same as call, but does not return any return values.

Trait Implementations

impl FromLua for LuaFunction

fn from_lua(state: &mut State, index: Index) -> Option<LuaFunction>

Converts the value on top of the stack of a Lua state to a value of type Option<Self>.

impl LuaStackable for LuaFunction

fn get_pos(&self) -> Index

Get the position of this value on the stack

impl ToLua for LuaFunction

fn to_lua(&self, state: &mut State)

Pushes a value of type Self onto the stack of a Lua state.