Trait tlua::PushOne

pub trait PushOne<L: AsLua>: Push<L> { }

Extension trait for Push. Guarantees that only one element will be pushed.

This should be implemented on most types that implement Push, except for tuples.

Note: Implementing this trait on a type that pushes multiple elements will most likely result in panics.

Implementations on Foreign Types

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

impl<L, T> PushOne<L> for [T] where
    L: AsLua,
    T: Push<LuaState>, 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<L> PushOne<L> for CString where
    L: AsLua, 

impl<L> PushOne<L> for str where
    L: AsLua, 

impl<L> PushOne<L> for CStr where
    L: AsLua, 

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

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

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

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

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

Implementors

impl<'c, L> PushOne<L> for LuaCode<'c> where
    L: AsLua, 

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

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

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

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

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

impl<L, T> PushOne<L> for Callable<T> where
    L: AsLua, 

impl<L, T> PushOne<L> for Indexable<T> where
    L: AsLua, 

impl<L, T> PushOne<L> for IndexableRW<T> where
    L: AsLua, 

impl<L, T> PushOne<L> for LuaFunction<T> where
    L: AsLua, 

impl<L, T> PushOne<L> for LuaTable<T> where
    L: AsLua, 

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

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> PushOne<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,
    Self: Copy + 'static,
    (A, B, C, D, E, F, G, H, I, J, K, M, N): for<'p> LuaRead<&'p InsideCallback>,
    R: PushInto<InsideCallback> + 'static, 

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> PushOne<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,
    Self: Copy + 'static,
    (B, C, D, E, F, G, H, I, J, K, M, N): for<'p> LuaRead<&'p InsideCallback>,
    R: PushInto<InsideCallback> + 'static, 

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> PushOne<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,
    Self: Copy + 'static,
    (C, D, E, F, G, H, I, J, K, M, N): for<'p> LuaRead<&'p InsideCallback>,
    R: PushInto<InsideCallback> + 'static, 

impl<L, Z, R, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, M: 'static, N: 'static> PushOne<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,
    Self: Copy + 'static,
    (D, E, F, G, H, I, J, K, M, N): for<'p> LuaRead<&'p InsideCallback>,
    R: PushInto<InsideCallback> + 'static, 

impl<L, Z, R, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, M: 'static, N: 'static> PushOne<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,
    Self: Copy + 'static,
    (E, F, G, H, I, J, K, M, N): for<'p> LuaRead<&'p InsideCallback>,
    R: PushInto<InsideCallback> + 'static, 

impl<L, Z, R, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, M: 'static, N: 'static> PushOne<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,
    Self: Copy + 'static,
    (F, G, H, I, J, K, M, N): for<'p> LuaRead<&'p InsideCallback>,
    R: PushInto<InsideCallback> + 'static, 

impl<L, Z, R, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, M: 'static, N: 'static> PushOne<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,
    Self: Copy + 'static,
    (G, H, I, J, K, M, N): for<'p> LuaRead<&'p InsideCallback>,
    R: PushInto<InsideCallback> + 'static, 

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

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

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

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

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

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

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

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