Struct me3_framework::scripting::lua::prelude::LuaFunction

pub struct LuaFunction<'lua>(_);

Handle to an internal Lua function.

Implementations

impl<'lua> Function<'lua>

pub fn call<A, R>(&self, args: A) -> Result<R, Error>where
    A: ToLuaMulti<'lua>,
    R: FromLuaMulti<'lua>,

Calls the function, passing args as function arguments.

The function’s return values are converted to the generic type R.

Examples

Call Lua’s built-in tostring function:

let globals = lua.globals();

let tostring: Function = globals.get("tostring")?;

assert_eq!(tostring.call::<_, String>(123)?, "123");

Call a function with multiple arguments:

let sum: Function = lua.load(
    r#"
        function(a, b)
            return a + b
        end
"#).eval()?;

assert_eq!(sum.call::<_, u32>((3, 4))?, 3 + 4);

pub fn call_async<'fut, A, R>(
    &self,
    args: A
) -> Pin<Box<dyn Future<Output = Result<R, Error>> + 'fut, Global>>where
    'lua: 'fut,
    A: ToLuaMulti<'lua>,
    R: 'fut + FromLuaMulti<'lua>,

Returns a future that, when polled, calls self, passing args as function arguments, and drives the execution.

Internally it wraps the function to an AsyncThread.

Requires feature = "async"

Examples

use std::time::Duration;
use futures_timer::Delay;

let sleep = lua.create_async_function(move |_lua, n: u64| async move {
    Delay::new(Duration::from_millis(n)).await;
    Ok(())
})?;

sleep.call_async(10).await?;

pub fn bind<A>(&self, args: A) -> Result<Function<'lua>, Error>where
    A: ToLuaMulti<'lua>,

Returns a function that, when called, calls self, passing args as the first set of arguments.

If any arguments are passed to the returned function, they will be passed after args.

Examples

let sum: Function = lua.load(
    r#"
        function(a, b)
            return a + b
        end
"#).eval()?;

let bound_a = sum.bind(1)?;
assert_eq!(bound_a.call::<_, u32>(2)?, 1 + 2);

let bound_a_and_b = sum.bind(13)?.bind(57)?;
assert_eq!(bound_a_and_b.call::<_, u32>(())?, 13 + 57);

pub fn info(&self) -> FunctionInfo

Returns information about the function.

Corresponds to the >Sn what mask for lua_getinfo when applied to the function.

pub fn coverage<F>(&self, func: F)where
    F: FnMut(CoverageInfo),

Retrieves recorded coverage information about this Lua function including inner calls.

This function takes a callback as an argument and calls it providing CoverageInfo snapshot per each executed inner function.

Recording of coverage information is controlled by Compiler::set_coverage_level option.

Requires feature = "luau"

Trait Implementations

impl<'lua> Clone for Function<'lua>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'lua> Debug for Function<'lua>

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

Formats the value using the given formatter.

impl<'lua> FromLua<'lua> for Function<'lua>

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

Performs the conversion.

impl<'lua> PartialEq<Function<'lua>> for Function<'lua>

fn eq(&self, other: &Function<'lua>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<'lua> ToLua<'lua> for Function<'lua>

fn to_lua(self, &'lua Lua) -> Result<Value<'lua>, Error>

Performs the conversion.