Trait ezlua::convert::ToLuaMulti

pub trait ToLuaMulti: Sized {
    const VALUE_COUNT: Option<usize> = None;

    // Provided methods
    fn value_count(&self) -> Option<usize> { ... }
    fn push_multi(self, lua: &State) -> Result<usize> { ... }
}

Types which can be pushed onto lua stack, as returned multiple values to lua function, or as passed multiple arguments to lua function

Provided Associated Constants

const VALUE_COUNT: Option<usize> = None

Count of values to be pushed to lua stack

Provided Methods

fn value_count(&self) -> Option<usize>

Get the count of values to be pushed to lua stack, with self instance

fn push_multi(self, lua: &State) -> Result<usize>

Define how to push values onto lua stack

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl ToLuaMulti for ExitStatus

const VALUE_COUNT: Option<usize> = <(bool, Option<i32>) as crate::prelude::ToLuaMulti>::VALUE_COUNT

fn push_multi(self, lua: &LuaState) -> LuaResult<usize>

impl<A> ToLuaMulti for Option<(A,)>

where A: ToLua,

fn value_count(&self) -> Option<usize>

fn push_multi<'a>(self, s: &'a State) -> Result<usize>

impl<A> ToLuaMulti for (A,)

where A: ToLua,

const VALUE_COUNT: Option<usize> = _

fn push_multi(self, s: &State) -> Result<usize>

impl<A, B> ToLuaMulti for Option<(A, B)>

where A: ToLua, B: ToLua,

fn value_count(&self) -> Option<usize>

fn push_multi<'a>(self, s: &'a State) -> Result<usize>

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

where A: ToLua, B: ToLua,

const VALUE_COUNT: Option<usize> = _

fn push_multi(self, s: &State) -> Result<usize>

impl<A, B, C> ToLuaMulti for Option<(A, B, C)>

where A: ToLua, B: ToLua, C: ToLua,

fn value_count(&self) -> Option<usize>

fn push_multi<'a>(self, s: &'a State) -> Result<usize>

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

where A: ToLua, B: ToLua, C: ToLua,

const VALUE_COUNT: Option<usize> = _

fn push_multi(self, s: &State) -> Result<usize>

impl<A, B, C, D> ToLuaMulti for Option<(A, B, C, D)>

where A: ToLua, B: ToLua, C: ToLua, D: ToLua,

fn value_count(&self) -> Option<usize>

fn push_multi<'a>(self, s: &'a State) -> Result<usize>

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

where A: ToLua, B: ToLua, C: ToLua, D: ToLua,

const VALUE_COUNT: Option<usize> = _

fn push_multi(self, s: &State) -> Result<usize>

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

where A: ToLua, B: ToLua, C: ToLua, D: ToLua, E: ToLua,

fn value_count(&self) -> Option<usize>

fn push_multi<'a>(self, s: &'a State) -> Result<usize>

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

where A: ToLua, B: ToLua, C: ToLua, D: ToLua, E: ToLua,

const VALUE_COUNT: Option<usize> = _

fn push_multi(self, s: &State) -> Result<usize>

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

where A: ToLua, B: ToLua, C: ToLua, D: ToLua, E: ToLua, F: ToLua,

fn value_count(&self) -> Option<usize>

fn push_multi<'a>(self, s: &'a State) -> Result<usize>

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

where A: ToLua, B: ToLua, C: ToLua, D: ToLua, E: ToLua, F: ToLua,

const VALUE_COUNT: Option<usize> = _

fn push_multi(self, s: &State) -> Result<usize>

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

where A: ToLua, B: ToLua, C: ToLua, D: ToLua, E: ToLua, F: ToLua, G: ToLua,

fn value_count(&self) -> Option<usize>

fn push_multi<'a>(self, s: &'a State) -> Result<usize>

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

where A: ToLua, B: ToLua, C: ToLua, D: ToLua, E: ToLua, F: ToLua, G: ToLua,

const VALUE_COUNT: Option<usize> = _

fn push_multi(self, s: &State) -> Result<usize>

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

where A: ToLua, B: ToLua, C: ToLua, D: ToLua, E: ToLua, F: ToLua, G: ToLua, H: ToLua,

fn value_count(&self) -> Option<usize>

fn push_multi<'a>(self, s: &'a State) -> Result<usize>

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

where A: ToLua, B: ToLua, C: ToLua, D: ToLua, E: ToLua, F: ToLua, G: ToLua, H: ToLua,

const VALUE_COUNT: Option<usize> = _

fn push_multi(self, s: &State) -> Result<usize>

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

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

fn value_count(&self) -> Option<usize>

fn push_multi<'a>(self, s: &'a State) -> Result<usize>

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

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

const VALUE_COUNT: Option<usize> = _

fn push_multi(self, s: &State) -> Result<usize>

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

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

fn value_count(&self) -> Option<usize>

fn push_multi<'a>(self, s: &'a State) -> Result<usize>

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

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

const VALUE_COUNT: Option<usize> = _

fn push_multi(self, s: &State) -> Result<usize>

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

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

fn value_count(&self) -> Option<usize>

fn push_multi<'a>(self, s: &'a State) -> Result<usize>

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

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

const VALUE_COUNT: Option<usize> = _

fn push_multi(self, s: &State) -> Result<usize>

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

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

fn value_count(&self) -> Option<usize>

fn push_multi<'a>(self, s: &'a State) -> Result<usize>

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

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

const VALUE_COUNT: Option<usize> = _

fn push_multi(self, s: &State) -> Result<usize>

impl<T: ToLua> ToLuaMulti for Range<T>

const VALUE_COUNT: Option<usize> = _

fn push_multi(self, s: &LuaState) -> Result<usize>

impl<T: ToLuaMulti, E: Debug + Send + Sync + 'static> ToLuaMulti for Result<T, E>

fn push_multi(self, s: &State) -> Result<usize>

Implementors

impl ToLuaMulti for Pushed

impl<T: ToLua> ToLuaMulti for MultiRet<T>

impl<T: ToLua> ToLuaMulti for T

const VALUE_COUNT: Option<usize> = _

impl<T: ToLuaMulti> ToLuaMulti for NilError<T>