Trait FromLuaMulti

pub trait FromLuaMulti: Sized {
    // Required method
    fn from_lua_multi(values: MultiValue, lua: &Lua) -> Result<Self>;
}

Trait for types that can be created from an arbitrary number of Lua values.

This is a generalization of FromLua, allowing an arbitrary number of Lua values to participate in the conversion. Any type that implements FromLua will automatically implement this trait.

Required Methods

fn from_lua_multi(values: MultiValue, lua: &Lua) -> Result<Self>

Performs the conversion.

In case values contains more values than needed to perform the conversion, the excess values should be ignored. This reflects the semantics of Lua when calling a function or assigning values. Similarly, if not enough values are given, conversions should assume that any missing values are nil.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl FromLuaMulti for ()

fn from_lua_multi(_values: MultiValue, _lua: &Lua) -> Result<Self>

impl<A> FromLuaMulti for (A,)

where A: FromLuaMulti,

fn from_lua_multi(values: MultiValue, lua: &Lua) -> Result<Self>

impl<B, A> FromLuaMulti for (B, A)

where B: FromLua, A: FromLuaMulti,

fn from_lua_multi(values: MultiValue, lua: &Lua) -> Result<Self>

impl<B, C, A> FromLuaMulti for (B, C, A)

where B: FromLua, C: FromLua, A: FromLuaMulti,

fn from_lua_multi(values: MultiValue, lua: &Lua) -> Result<Self>

impl<B, C, D, A> FromLuaMulti for (B, C, D, A)

where B: FromLua, C: FromLua, D: FromLua, A: FromLuaMulti,

fn from_lua_multi(values: MultiValue, lua: &Lua) -> Result<Self>

impl<B, C, D, E, A> FromLuaMulti for (B, C, D, E, A)

where B: FromLua, C: FromLua, D: FromLua, E: FromLua, A: FromLuaMulti,

fn from_lua_multi(values: MultiValue, lua: &Lua) -> Result<Self>

impl<B, C, D, E, F, A> FromLuaMulti for (B, C, D, E, F, A)

where B: FromLua, C: FromLua, D: FromLua, E: FromLua, F: FromLua, A: FromLuaMulti,

fn from_lua_multi(values: MultiValue, lua: &Lua) -> Result<Self>

impl<B, C, D, E, F, G, A> FromLuaMulti for (B, C, D, E, F, G, A)

where B: FromLua, C: FromLua, D: FromLua, E: FromLua, F: FromLua, G: FromLua, A: FromLuaMulti,

fn from_lua_multi(values: MultiValue, lua: &Lua) -> Result<Self>

impl<B, C, D, E, F, G, H, A> FromLuaMulti for (B, C, D, E, F, G, H, A)

where B: FromLua, C: FromLua, D: FromLua, E: FromLua, F: FromLua, G: FromLua, H: FromLua, A: FromLuaMulti,

fn from_lua_multi(values: MultiValue, lua: &Lua) -> Result<Self>

impl<B, C, D, E, F, G, H, I, A> FromLuaMulti for (B, C, D, E, F, G, H, I, A)

where B: FromLua, C: FromLua, D: FromLua, E: FromLua, F: FromLua, G: FromLua, H: FromLua, I: FromLua, A: FromLuaMulti,

fn from_lua_multi(values: MultiValue, lua: &Lua) -> Result<Self>

impl<B, C, D, E, F, G, H, I, J, A> FromLuaMulti for (B, C, D, E, F, G, H, I, J, A)

where B: FromLua, C: FromLua, D: FromLua, E: FromLua, F: FromLua, G: FromLua, H: FromLua, I: FromLua, J: FromLua, A: FromLuaMulti,

fn from_lua_multi(values: MultiValue, lua: &Lua) -> Result<Self>

impl<B, C, D, E, F, G, H, I, J, K, A> FromLuaMulti for (B, C, D, E, F, G, H, I, J, K, A)

where B: FromLua, C: FromLua, D: FromLua, E: FromLua, F: FromLua, G: FromLua, H: FromLua, I: FromLua, J: FromLua, K: FromLua, A: FromLuaMulti,

fn from_lua_multi(values: MultiValue, lua: &Lua) -> Result<Self>

impl<B, C, D, E, F, G, H, I, J, K, L, A> FromLuaMulti for (B, C, D, E, F, G, H, I, J, K, L, A)

where B: FromLua, C: FromLua, D: FromLua, E: FromLua, F: FromLua, G: FromLua, H: FromLua, I: FromLua, J: FromLua, K: FromLua, L: FromLua, A: FromLuaMulti,

fn from_lua_multi(values: MultiValue, lua: &Lua) -> Result<Self>

impl<B, C, D, E, F, G, H, I, J, K, L, M, A> FromLuaMulti for (B, C, D, E, F, G, H, I, J, K, L, M, A)

where B: FromLua, C: FromLua, D: FromLua, E: FromLua, F: FromLua, G: FromLua, H: FromLua, I: FromLua, J: FromLua, K: FromLua, L: FromLua, M: FromLua, A: FromLuaMulti,

fn from_lua_multi(values: MultiValue, lua: &Lua) -> Result<Self>

impl<B, C, D, E, F, G, H, I, J, K, L, M, N, A> FromLuaMulti for (B, C, D, E, F, G, H, I, J, K, L, M, N, A)

where B: FromLua, C: FromLua, D: FromLua, E: FromLua, F: FromLua, G: FromLua, H: FromLua, I: FromLua, J: FromLua, K: FromLua, L: FromLua, M: FromLua, N: FromLua, A: FromLuaMulti,

fn from_lua_multi(values: MultiValue, lua: &Lua) -> Result<Self>

impl<B, C, D, E, F, G, H, I, J, K, L, M, N, O, A> FromLuaMulti for (B, C, D, E, F, G, H, I, J, K, L, M, N, O, A)

where B: FromLua, C: FromLua, D: FromLua, E: FromLua, F: FromLua, G: FromLua, H: FromLua, I: FromLua, J: FromLua, K: FromLua, L: FromLua, M: FromLua, N: FromLua, O: FromLua, A: FromLuaMulti,

fn from_lua_multi(values: MultiValue, lua: &Lua) -> Result<Self>

impl<B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, A> FromLuaMulti for (B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, A)

where B: FromLua, C: FromLua, D: FromLua, E: FromLua, F: FromLua, G: FromLua, H: FromLua, I: FromLua, J: FromLua, K: FromLua, L: FromLua, M: FromLua, N: FromLua, O: FromLua, P: FromLua, A: FromLuaMulti,

fn from_lua_multi(values: MultiValue, lua: &Lua) -> Result<Self>

Implementors

impl FromLuaMulti for MultiValue

impl<T: FromLua> FromLuaMulti for Variadic<T>

impl<T: FromLua> FromLuaMulti for T