Trait PushOneInto 

pub trait PushOneInto<L: AsLua>: PushInto<L> { }

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

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

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

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<L, K, S> PushOneInto<L> for HashSet<K, S>

where L: AsLua, K: PushOneInto<LuaState> + Eq + Hash + Debug,

impl<L, K, V, S> PushOneInto<L> for HashMap<K, V, S>

where L: AsLua, K: PushOneInto<LuaState> + Eq + Hash + Debug, V: PushOneInto<LuaState> + Debug,

impl<L, T, const N: usize> PushOneInto<L> for [T; N]

where L: AsLua, T: PushInto<LuaState>,

impl<L, T> PushOneInto<L> for Option<T>

where T: PushOneInto<L>, L: AsLua,

impl<L, T> PushOneInto<L> for Vec<T>

where L: AsLua, T: PushInto<LuaState>,

impl<L> PushOneInto<L> for ()

where L: AsLua,

impl<L> PushOneInto<L> for CString

where L: AsLua,

impl<L> PushOneInto<L> for OsString

where L: AsLua,

impl<L> PushOneInto<L> for PathBuf

where L: AsLua,

impl<L> PushOneInto<L> for String

where L: AsLua,

impl<L> PushOneInto<L> for bool

where L: AsLua,

impl<L> PushOneInto<L> for f32

where L: AsLua,

impl<L> PushOneInto<L> for f64

where L: AsLua,

impl<L> PushOneInto<L> for i8

where L: AsLua,

impl<L> PushOneInto<L> for i16

where L: AsLua,

impl<L> PushOneInto<L> for i32

where L: AsLua,

impl<L> PushOneInto<L> for i64

where L: AsLua,

impl<L> PushOneInto<L> for isize

where L: AsLua,

impl<L> PushOneInto<L> for u8

where L: AsLua,

impl<L> PushOneInto<L> for u16

where L: AsLua,

impl<L> PushOneInto<L> for u32

where L: AsLua,

impl<L> PushOneInto<L> for u64

where L: AsLua,

impl<L> PushOneInto<L> for usize

where L: AsLua,

impl<LU, M> PushOneInto<LU> for (M,)

where LU: AsLua, M: PushOneInto<LU>,

impl<T, E> PushOneInto<InsideCallback> for Result<T, E>

where T: PushOneInto<InsideCallback>, E: Display,

impl<T, L> PushOneInto<L> for &T

where L: AsLua, T: ?Sized + PushOne<L>,

Implementors

impl<L, I> PushOneInto<L> for TableFromIter<I>

where L: AsLua, I: Iterator, <I as Iterator>::Item: PushInto<LuaState>,

impl<L, R> PushOneInto<L> for LuaCodeFromReader<R>

where L: AsLua, R: Read,

impl<L, T> PushOneInto<L> for CData<T>

where L: AsLua, T: AsCData + Copy,

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> PushOneInto<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 + '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> PushOneInto<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 + '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> PushOneInto<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 + '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> PushOneInto<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 + '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> PushOneInto<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 + '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> PushOneInto<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 + '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> PushOneInto<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 + '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> PushOneInto<L> for Function<Z, (H, I, J, K, M, N), R>

where L: AsLua, Z: FnMut(H, I, J, K, M, N) -> R + '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> PushOneInto<L> for Function<Z, (I, J, K, M, N), R>

where L: AsLua, Z: FnMut(I, J, K, M, N) -> R + '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> PushOneInto<L> for Function<Z, (J, K, M, N), R>

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

impl<L, Z, R, K: 'static, M: 'static, N: 'static> PushOneInto<L> for Function<Z, (K, M, N), R>

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

impl<L, Z, R, M: 'static, N: 'static> PushOneInto<L> for Function<Z, (M, N), R>

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

impl<L, Z, R, N: 'static> PushOneInto<L> for Function<Z, (N,), R>

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

impl<L, Z, R> PushOneInto<L> for Function<Z, (), R>

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

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

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

impl<L> PushOneInto<L> for AnyLuaString

where L: AsLua,

impl<L> PushOneInto<L> for False

where L: AsLua,

impl<L> PushOneInto<L> for Nil

where L: AsLua,

impl<L> PushOneInto<L> for Null

where L: AsLua,

impl<L> PushOneInto<L> for Object<L>

where L: AsLua,

impl<L> PushOneInto<L> for True

where L: AsLua,

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

where LU: AsLua, A: PushInto<LuaState>, B: PushInto<LuaState>, C: PushInto<LuaState>, D: PushInto<LuaState>, E: PushInto<LuaState>, F: PushInto<LuaState>, G: PushInto<LuaState>, H: PushInto<LuaState>, I: PushInto<LuaState>, J: PushInto<LuaState>, K: PushInto<LuaState>, L: PushInto<LuaState>, M: PushInto<LuaState>,

impl<LU, B, C, D, E, F, G, H, I, J, K, L, M> PushOneInto<LU> for AsTable<(B, C, D, E, F, G, H, I, J, K, L, M)>

where LU: AsLua, B: PushInto<LuaState>, C: PushInto<LuaState>, D: PushInto<LuaState>, E: PushInto<LuaState>, F: PushInto<LuaState>, G: PushInto<LuaState>, H: PushInto<LuaState>, I: PushInto<LuaState>, J: PushInto<LuaState>, K: PushInto<LuaState>, L: PushInto<LuaState>, M: PushInto<LuaState>,

impl<LU, C, D, E, F, G, H, I, J, K, L, M> PushOneInto<LU> for AsTable<(C, D, E, F, G, H, I, J, K, L, M)>

where LU: AsLua, C: PushInto<LuaState>, D: PushInto<LuaState>, E: PushInto<LuaState>, F: PushInto<LuaState>, G: PushInto<LuaState>, H: PushInto<LuaState>, I: PushInto<LuaState>, J: PushInto<LuaState>, K: PushInto<LuaState>, L: PushInto<LuaState>, M: PushInto<LuaState>,

impl<LU, D, E, F, G, H, I, J, K, L, M> PushOneInto<LU> for AsTable<(D, E, F, G, H, I, J, K, L, M)>

where LU: AsLua, D: PushInto<LuaState>, E: PushInto<LuaState>, F: PushInto<LuaState>, G: PushInto<LuaState>, H: PushInto<LuaState>, I: PushInto<LuaState>, J: PushInto<LuaState>, K: PushInto<LuaState>, L: PushInto<LuaState>, M: PushInto<LuaState>,

impl<LU, E, F, G, H, I, J, K, L, M> PushOneInto<LU> for AsTable<(E, F, G, H, I, J, K, L, M)>

where LU: AsLua, E: PushInto<LuaState>, F: PushInto<LuaState>, G: PushInto<LuaState>, H: PushInto<LuaState>, I: PushInto<LuaState>, J: PushInto<LuaState>, K: PushInto<LuaState>, L: PushInto<LuaState>, M: PushInto<LuaState>,

impl<LU, F, G, H, I, J, K, L, M> PushOneInto<LU> for AsTable<(F, G, H, I, J, K, L, M)>

where LU: AsLua, F: PushInto<LuaState>, G: PushInto<LuaState>, H: PushInto<LuaState>, I: PushInto<LuaState>, J: PushInto<LuaState>, K: PushInto<LuaState>, L: PushInto<LuaState>, M: PushInto<LuaState>,

impl<LU, G, H, I, J, K, L, M> PushOneInto<LU> for AsTable<(G, H, I, J, K, L, M)>

where LU: AsLua, G: PushInto<LuaState>, H: PushInto<LuaState>, I: PushInto<LuaState>, J: PushInto<LuaState>, K: PushInto<LuaState>, L: PushInto<LuaState>, M: PushInto<LuaState>,

impl<LU, H, I, J, K, L, M> PushOneInto<LU> for AsTable<(H, I, J, K, L, M)>

where LU: AsLua, H: PushInto<LuaState>, I: PushInto<LuaState>, J: PushInto<LuaState>, K: PushInto<LuaState>, L: PushInto<LuaState>, M: PushInto<LuaState>,

impl<LU, I, J, K, L, M> PushOneInto<LU> for AsTable<(I, J, K, L, M)>

where LU: AsLua, I: PushInto<LuaState>, J: PushInto<LuaState>, K: PushInto<LuaState>, L: PushInto<LuaState>, M: PushInto<LuaState>,

impl<LU, J, K, L, M> PushOneInto<LU> for AsTable<(J, K, L, M)>

where LU: AsLua, J: PushInto<LuaState>, K: PushInto<LuaState>, L: PushInto<LuaState>, M: PushInto<LuaState>,

impl<LU, K, L, M> PushOneInto<LU> for AsTable<(K, L, M)>

where LU: AsLua, K: PushInto<LuaState>, L: PushInto<LuaState>, M: PushInto<LuaState>,

impl<LU, L, M> PushOneInto<LU> for AsTable<(L, M)>

where LU: AsLua, L: PushInto<LuaState>, M: PushInto<LuaState>,

impl<LU, M> PushOneInto<LU> for AsTable<(M,)>

where LU: AsLua, M: PushOneInto<LuaState>,