Trait tlua::PushInto

pub trait PushInto<L> where
    L: AsLua, {
    type Err;
    fn push_into_lua(self, lua: L) -> Result<PushGuard<L>, (Self::Err, L)>;

    fn push_into_no_err(self, lua: L) -> PushGuard<L>
    where
        Self: Sized,
        <Self as PushInto<L>>::Err: Into<Void>,
    { ... }
}

Types implementing this trait can be pushed onto the Lua stack by value.

Associated Types

type Err

Required methods

fn push_into_lua(self, lua: L) -> Result<PushGuard<L>, (Self::Err, L)>

Push the value into lua by value

Provided methods

fn push_into_no_err(self, lua: L) -> PushGuard<L> where
    Self: Sized,
    <Self as PushInto<L>>::Err: Into<Void>, 

Same as push_into_lua but can only succeed and is only available if Err implements Into<Void>.

Implementations on Foreign Types

impl<T, E> PushInto<InsideCallback> for Result<T, E> where
    T: PushInto<InsideCallback>,
    E: Display, 

type Err = T::Err

fn push_into_lua(
    self,
    lua: InsideCallback
) -> Result<PushGuard<InsideCallback>, (T::Err, InsideCallback)>

impl<L, T> PushInto<L> for Vec<T> where
    L: AsLua,
    T: PushInto<LuaState>, 

type Err = PushIterError<T::Err>

fn push_into_lua(self, lua: L) -> Result<PushGuard<L>, (Self::Err, L)>

impl<L, T, const N: usize> PushInto<L> for [T; N] where
    L: AsLua,
    T: PushInto<LuaState>, 

type Err = PushIterError<T::Err>

fn push_into_lua(self, lua: L) -> Result<PushGuard<L>, (Self::Err, L)>

impl<L, K, V> PushInto<L> for HashMap<K, V> where
    L: AsLua,
    K: PushOneInto<LuaState> + Eq + Hash + Debug,
    V: PushOneInto<LuaState> + Debug, 

type Err = TuplePushError<K::Err, V::Err>

fn push_into_lua(self, lua: L) -> Result<PushGuard<L>, (Self::Err, L)>

impl<L, K> PushInto<L> for HashSet<K> where
    L: AsLua,
    K: PushOneInto<LuaState> + Eq + Hash + Debug, 

type Err = K::Err

fn push_into_lua(self, lua: L) -> Result<PushGuard<L>, (K::Err, L)>

impl<L> PushInto<L> for i64 where
    L: AsLua, 

type Err = Void

fn push_into_lua(self, lua: L) -> Result<PushGuard<L>, (Void, L)>

impl<L> PushInto<L> for i32 where
    L: AsLua, 

type Err = Void

fn push_into_lua(self, lua: L) -> Result<PushGuard<L>, (Void, L)>

impl<L> PushInto<L> for i16 where
    L: AsLua, 

type Err = Void

fn push_into_lua(self, lua: L) -> Result<PushGuard<L>, (Void, L)>

impl<L> PushInto<L> for i8 where
    L: AsLua, 

type Err = Void

fn push_into_lua(self, lua: L) -> Result<PushGuard<L>, (Void, L)>

impl<L> PushInto<L> for u64 where
    L: AsLua, 

type Err = Void

fn push_into_lua(self, lua: L) -> Result<PushGuard<L>, (Void, L)>

impl<L> PushInto<L> for u32 where
    L: AsLua, 

type Err = Void

fn push_into_lua(self, lua: L) -> Result<PushGuard<L>, (Void, L)>

impl<L> PushInto<L> for u16 where
    L: AsLua, 

type Err = Void

fn push_into_lua(self, lua: L) -> Result<PushGuard<L>, (Void, L)>

impl<L> PushInto<L> for u8 where
    L: AsLua, 

type Err = Void

fn push_into_lua(self, lua: L) -> Result<PushGuard<L>, (Void, L)>

impl<L> PushInto<L> for f64 where
    L: AsLua, 

type Err = Void

fn push_into_lua(self, lua: L) -> Result<PushGuard<L>, (Void, L)>

impl<L> PushInto<L> for f32 where
    L: AsLua, 

type Err = Void

fn push_into_lua(self, lua: L) -> Result<PushGuard<L>, (Void, L)>

impl<L> PushInto<L> for String where
    L: AsLua, 

type Err = Void

fn push_into_lua(self, lua: L) -> Result<PushGuard<L>, (Void, L)>

impl<L> PushInto<L> for bool where
    L: AsLua, 

type Err = Void

fn push_into_lua(self, lua: L) -> Result<PushGuard<L>, (Void, L)>

impl<L> PushInto<L> for () where
    L: AsLua, 

type Err = Void

fn push_into_lua(self, lua: L) -> Result<PushGuard<L>, (Void, L)>

impl<L, T> PushInto<L> for Option<T> where
    T: PushInto<L>,
    L: AsLua, 

type Err = T::Err

fn push_into_lua(self, lua: L) -> Result<PushGuard<L>, (Self::Err, L)>

impl<LU, A, B, C, D, E, F, G, H, I, J, K, L, M> PushInto<LU> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    LU: AsLua,
    A: Debug + PushInto<LuaState>,
    B: Debug + PushInto<LuaState>,
    C: Debug + PushInto<LuaState>,
    D: Debug + PushInto<LuaState>,
    E: Debug + PushInto<LuaState>,
    F: Debug + PushInto<LuaState>,
    G: Debug + PushInto<LuaState>,
    H: Debug + PushInto<LuaState>,
    I: Debug + PushInto<LuaState>,
    J: Debug + PushInto<LuaState>,
    K: Debug + PushInto<LuaState>,
    L: Debug + PushInto<LuaState>,
    M: Debug + PushInto<LuaState>, 

type Err = TuplePushError<<A as PushInto<LuaState>>::Err, <(B, C, D, E, F, G, H, I, J, K, L, M) as PushInto<LuaState>>::Err>

fn push_into_lua(self, lua: LU) -> Result<PushGuard<LU>, (Self::Err, LU)>

impl<LU, B, C, D, E, F, G, H, I, J, K, L, M> PushInto<LU> for (B, C, D, E, F, G, H, I, J, K, L, M) where
    LU: AsLua,
    B: Debug + PushInto<LuaState>,
    C: Debug + PushInto<LuaState>,
    D: Debug + PushInto<LuaState>,
    E: Debug + PushInto<LuaState>,
    F: Debug + PushInto<LuaState>,
    G: Debug + PushInto<LuaState>,
    H: Debug + PushInto<LuaState>,
    I: Debug + PushInto<LuaState>,
    J: Debug + PushInto<LuaState>,
    K: Debug + PushInto<LuaState>,
    L: Debug + PushInto<LuaState>,
    M: Debug + PushInto<LuaState>, 

type Err = TuplePushError<<B as PushInto<LuaState>>::Err, <(C, D, E, F, G, H, I, J, K, L, M) as PushInto<LuaState>>::Err>

fn push_into_lua(self, lua: LU) -> Result<PushGuard<LU>, (Self::Err, LU)>

impl<LU, C, D, E, F, G, H, I, J, K, L, M> PushInto<LU> for (C, D, E, F, G, H, I, J, K, L, M) where
    LU: AsLua,
    C: Debug + PushInto<LuaState>,
    D: Debug + PushInto<LuaState>,
    E: Debug + PushInto<LuaState>,
    F: Debug + PushInto<LuaState>,
    G: Debug + PushInto<LuaState>,
    H: Debug + PushInto<LuaState>,
    I: Debug + PushInto<LuaState>,
    J: Debug + PushInto<LuaState>,
    K: Debug + PushInto<LuaState>,
    L: Debug + PushInto<LuaState>,
    M: Debug + PushInto<LuaState>, 

type Err = TuplePushError<<C as PushInto<LuaState>>::Err, <(D, E, F, G, H, I, J, K, L, M) as PushInto<LuaState>>::Err>

fn push_into_lua(self, lua: LU) -> Result<PushGuard<LU>, (Self::Err, LU)>

impl<LU, D, E, F, G, H, I, J, K, L, M> PushInto<LU> for (D, E, F, G, H, I, J, K, L, M) where
    LU: AsLua,
    D: Debug + PushInto<LuaState>,
    E: Debug + PushInto<LuaState>,
    F: Debug + PushInto<LuaState>,
    G: Debug + PushInto<LuaState>,
    H: Debug + PushInto<LuaState>,
    I: Debug + PushInto<LuaState>,
    J: Debug + PushInto<LuaState>,
    K: Debug + PushInto<LuaState>,
    L: Debug + PushInto<LuaState>,
    M: Debug + PushInto<LuaState>, 

type Err = TuplePushError<<D as PushInto<LuaState>>::Err, <(E, F, G, H, I, J, K, L, M) as PushInto<LuaState>>::Err>

fn push_into_lua(self, lua: LU) -> Result<PushGuard<LU>, (Self::Err, LU)>

impl<LU, E, F, G, H, I, J, K, L, M> PushInto<LU> for (E, F, G, H, I, J, K, L, M) where
    LU: AsLua,
    E: Debug + PushInto<LuaState>,
    F: Debug + PushInto<LuaState>,
    G: Debug + PushInto<LuaState>,
    H: Debug + PushInto<LuaState>,
    I: Debug + PushInto<LuaState>,
    J: Debug + PushInto<LuaState>,
    K: Debug + PushInto<LuaState>,
    L: Debug + PushInto<LuaState>,
    M: Debug + PushInto<LuaState>, 

type Err = TuplePushError<<E as PushInto<LuaState>>::Err, <(F, G, H, I, J, K, L, M) as PushInto<LuaState>>::Err>

fn push_into_lua(self, lua: LU) -> Result<PushGuard<LU>, (Self::Err, LU)>

impl<LU, F, G, H, I, J, K, L, M> PushInto<LU> for (F, G, H, I, J, K, L, M) where
    LU: AsLua,
    F: Debug + PushInto<LuaState>,
    G: Debug + PushInto<LuaState>,
    H: Debug + PushInto<LuaState>,
    I: Debug + PushInto<LuaState>,
    J: Debug + PushInto<LuaState>,
    K: Debug + PushInto<LuaState>,
    L: Debug + PushInto<LuaState>,
    M: Debug + PushInto<LuaState>, 

type Err = TuplePushError<<F as PushInto<LuaState>>::Err, <(G, H, I, J, K, L, M) as PushInto<LuaState>>::Err>

fn push_into_lua(self, lua: LU) -> Result<PushGuard<LU>, (Self::Err, LU)>

impl<LU, G, H, I, J, K, L, M> PushInto<LU> for (G, H, I, J, K, L, M) where
    LU: AsLua,
    G: Debug + PushInto<LuaState>,
    H: Debug + PushInto<LuaState>,
    I: Debug + PushInto<LuaState>,
    J: Debug + PushInto<LuaState>,
    K: Debug + PushInto<LuaState>,
    L: Debug + PushInto<LuaState>,
    M: Debug + PushInto<LuaState>, 

type Err = TuplePushError<<G as PushInto<LuaState>>::Err, <(H, I, J, K, L, M) as PushInto<LuaState>>::Err>

fn push_into_lua(self, lua: LU) -> Result<PushGuard<LU>, (Self::Err, LU)>

impl<LU, H, I, J, K, L, M> PushInto<LU> for (H, I, J, K, L, M) where
    LU: AsLua,
    H: Debug + PushInto<LuaState>,
    I: Debug + PushInto<LuaState>,
    J: Debug + PushInto<LuaState>,
    K: Debug + PushInto<LuaState>,
    L: Debug + PushInto<LuaState>,
    M: Debug + PushInto<LuaState>, 

type Err = TuplePushError<<H as PushInto<LuaState>>::Err, <(I, J, K, L, M) as PushInto<LuaState>>::Err>

fn push_into_lua(self, lua: LU) -> Result<PushGuard<LU>, (Self::Err, LU)>

impl<LU, I, J, K, L, M> PushInto<LU> for (I, J, K, L, M) where
    LU: AsLua,
    I: Debug + PushInto<LuaState>,
    J: Debug + PushInto<LuaState>,
    K: Debug + PushInto<LuaState>,
    L: Debug + PushInto<LuaState>,
    M: Debug + PushInto<LuaState>, 

type Err = TuplePushError<<I as PushInto<LuaState>>::Err, <(J, K, L, M) as PushInto<LuaState>>::Err>

fn push_into_lua(self, lua: LU) -> Result<PushGuard<LU>, (Self::Err, LU)>

impl<LU, J, K, L, M> PushInto<LU> for (J, K, L, M) where
    LU: AsLua,
    J: Debug + PushInto<LuaState>,
    K: Debug + PushInto<LuaState>,
    L: Debug + PushInto<LuaState>,
    M: Debug + PushInto<LuaState>, 

type Err = TuplePushError<<J as PushInto<LuaState>>::Err, <(K, L, M) as PushInto<LuaState>>::Err>

fn push_into_lua(self, lua: LU) -> Result<PushGuard<LU>, (Self::Err, LU)>

impl<LU, K, L, M> PushInto<LU> for (K, L, M) where
    LU: AsLua,
    K: Debug + PushInto<LuaState>,
    L: Debug + PushInto<LuaState>,
    M: Debug + PushInto<LuaState>, 

type Err = TuplePushError<<K as PushInto<LuaState>>::Err, <(L, M) as PushInto<LuaState>>::Err>

fn push_into_lua(self, lua: LU) -> Result<PushGuard<LU>, (Self::Err, LU)>

impl<LU, L, M> PushInto<LU> for (L, M) where
    LU: AsLua,
    L: Debug + PushInto<LuaState>,
    M: Debug + PushInto<LuaState>, 

type Err = TuplePushError<<L as PushInto<LuaState>>::Err, <(M,) as PushInto<LuaState>>::Err>

fn push_into_lua(self, lua: LU) -> Result<PushGuard<LU>, (Self::Err, LU)>

impl<LU, M> PushInto<LU> for (M,) where
    LU: AsLua,
    M: PushInto<LU>, 

type Err = TuplePushError<<M as PushInto<LU>>::Err, Void>

fn push_into_lua(self, lua: LU) -> Result<PushGuard<LU>, (Self::Err, LU)>

impl<T, L> PushInto<L> for &T where
    L: AsLua,
    T: ?Sized,
    T: Push<L>, 

type Err = T::Err

fn push_into_lua(self, lua: L) -> Result<PushGuard<L>, (Self::Err, L)>

Implementors

impl<L> PushInto<L> for AnyLuaString where
    L: AsLua, 

type Err = Void

impl<L> PushInto<L> for False where
    L: AsLua, 

type Err = Void

impl<L> PushInto<L> for Nil where
    L: AsLua, 

type Err = Void

impl<L> PushInto<L> for Null where
    L: AsLua, 

type Err = Void

impl<L> PushInto<L> for True where
    L: AsLua, 

type Err = Void

impl<L, R> PushInto<L> for LuaCodeFromReader<R> where
    L: AsLua,
    R: Read, 

type Err = LuaError

impl<L, Z, R> PushInto<L> for Function<Z, (), R> where
    L: AsLua,
    Z: FnMut() -> R,
    (): for<'p> LuaRead<&'p InsideCallback>,
    R: PushInto<InsideCallback> + 'static, 

type Err = Void

impl<L, Z, R, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, M: 'static, N: 'static> PushInto<L> for Function<Z, (A, B, C, D, E, F, G, H, I, J, K, M, N), R> where
    L: AsLua,
    Z: FnMut(A, B, C, D, E, F, G, H, I, J, K, M, N) -> R,
    (A, B, C, D, E, F, G, H, I, J, K, M, N): for<'p> LuaRead<&'p InsideCallback>,
    R: PushInto<InsideCallback> + 'static, 

type Err = Void

impl<L, Z, R, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, M: 'static, N: 'static> PushInto<L> for Function<Z, (B, C, D, E, F, G, H, I, J, K, M, N), R> where
    L: AsLua,
    Z: FnMut(B, C, D, E, F, G, H, I, J, K, M, N) -> R,
    (B, C, D, E, F, G, H, I, J, K, M, N): for<'p> LuaRead<&'p InsideCallback>,
    R: PushInto<InsideCallback> + 'static, 

type Err = Void

impl<L, Z, R, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, M: 'static, N: 'static> PushInto<L> for Function<Z, (C, D, E, F, G, H, I, J, K, M, N), R> where
    L: AsLua,
    Z: FnMut(C, D, E, F, G, H, I, J, K, M, N) -> R,
    (C, D, E, F, G, H, I, J, K, M, N): for<'p> LuaRead<&'p InsideCallback>,
    R: PushInto<InsideCallback> + 'static, 

type Err = Void

impl<L, Z, R, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, M: 'static, N: 'static> PushInto<L> for Function<Z, (D, E, F, G, H, I, J, K, M, N), R> where
    L: AsLua,
    Z: FnMut(D, E, F, G, H, I, J, K, M, N) -> R,
    (D, E, F, G, H, I, J, K, M, N): for<'p> LuaRead<&'p InsideCallback>,
    R: PushInto<InsideCallback> + 'static, 

type Err = Void

impl<L, Z, R, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, M: 'static, N: 'static> PushInto<L> for Function<Z, (E, F, G, H, I, J, K, M, N), R> where
    L: AsLua,
    Z: FnMut(E, F, G, H, I, J, K, M, N) -> R,
    (E, F, G, H, I, J, K, M, N): for<'p> LuaRead<&'p InsideCallback>,
    R: PushInto<InsideCallback> + 'static, 

type Err = Void

impl<L, Z, R, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, M: 'static, N: 'static> PushInto<L> for Function<Z, (F, G, H, I, J, K, M, N), R> where
    L: AsLua,
    Z: FnMut(F, G, H, I, J, K, M, N) -> R,
    (F, G, H, I, J, K, M, N): for<'p> LuaRead<&'p InsideCallback>,
    R: PushInto<InsideCallback> + 'static, 

type Err = Void

impl<L, Z, R, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, M: 'static, N: 'static> PushInto<L> for Function<Z, (G, H, I, J, K, M, N), R> where
    L: AsLua,
    Z: FnMut(G, H, I, J, K, M, N) -> R,
    (G, H, I, J, K, M, N): for<'p> LuaRead<&'p InsideCallback>,
    R: PushInto<InsideCallback> + 'static, 

type Err = Void

impl<L, Z, R, H: 'static, I: 'static, J: 'static, K: 'static, M: 'static, N: 'static> PushInto<L> for Function<Z, (H, I, J, K, M, N), R> where
    L: AsLua,
    Z: FnMut(H, I, J, K, M, N) -> R,
    (H, I, J, K, M, N): for<'p> LuaRead<&'p InsideCallback>,
    R: PushInto<InsideCallback> + 'static, 

type Err = Void

impl<L, Z, R, I: 'static, J: 'static, K: 'static, M: 'static, N: 'static> PushInto<L> for Function<Z, (I, J, K, M, N), R> where
    L: AsLua,
    Z: FnMut(I, J, K, M, N) -> R,
    (I, J, K, M, N): for<'p> LuaRead<&'p InsideCallback>,
    R: PushInto<InsideCallback> + 'static, 

type Err = Void

impl<L, Z, R, J: 'static, K: 'static, M: 'static, N: 'static> PushInto<L> for Function<Z, (J, K, M, N), R> where
    L: AsLua,
    Z: FnMut(J, K, M, N) -> R,
    (J, K, M, N): for<'p> LuaRead<&'p InsideCallback>,
    R: PushInto<InsideCallback> + 'static, 

type Err = Void

impl<L, Z, R, K: 'static, M: 'static, N: 'static> PushInto<L> for Function<Z, (K, M, N), R> where
    L: AsLua,
    Z: FnMut(K, M, N) -> R,
    (K, M, N): for<'p> LuaRead<&'p InsideCallback>,
    R: PushInto<InsideCallback> + 'static, 

type Err = Void

impl<L, Z, R, M: 'static, N: 'static> PushInto<L> for Function<Z, (M, N), R> where
    L: AsLua,
    Z: FnMut(M, N) -> R,
    (M, N): for<'p> LuaRead<&'p InsideCallback>,
    R: PushInto<InsideCallback> + 'static, 

type Err = Void

impl<L, Z, R, N: 'static> PushInto<L> for Function<Z, (N,), R> where
    L: AsLua,
    Z: FnMut(N) -> R,
    (N,): for<'p> LuaRead<&'p InsideCallback>,
    R: PushInto<InsideCallback> + 'static, 

type Err = Void

impl<L: AsLua> PushInto<L> for AnyHashableLuaValue

type Err = Void

impl<L: AsLua> PushInto<L> for AnyLuaValue

type Err = Void