Trait Pushable 

pub trait Pushable {
    // Required method
    unsafe fn push(self, lstate: *mut State) -> Result<i32, Error>;
}

Trait implemented for types that can be pushed onto the Lua stack.

Required Methods

unsafe fn push(self, lstate: *mut State) -> Result<i32, Error>

Pushes all its values on the Lua stack, returning the number of values that it pushed.

Dyn Compatibility

This trait is dyn compatible.

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

Implementations on Foreign Types

impl Pushable for ()

unsafe fn push(self, lstate: *mut State) -> Result<i32, Error>

impl Pushable for String

unsafe fn push(self, lstate: *mut State) -> Result<i32, Error>

impl Pushable for bool

unsafe fn push(self, lstate: *mut State) -> Result<i32, Error>

impl Pushable for f32

unsafe fn push(self, lstate: *mut State) -> Result<i32, Error>

impl Pushable for f64

unsafe fn push(self, lstate: *mut State) -> Result<i32, Error>

impl Pushable for i8

unsafe fn push(self, lstate: *mut State) -> Result<i32, Error>

impl Pushable for i16

unsafe fn push(self, lstate: *mut State) -> Result<i32, Error>

impl Pushable for i32

unsafe fn push(self, lstate: *mut State) -> Result<i32, Error>

impl Pushable for i64

unsafe fn push(self, lstate: *mut State) -> Result<i32, Error>

impl Pushable for isize

unsafe fn push(self, lstate: *mut State) -> Result<i32, Error>

impl Pushable for u8

unsafe fn push(self, lstate: *mut State) -> Result<i32, Error>

impl Pushable for u16

unsafe fn push(self, lstate: *mut State) -> Result<i32, Error>

impl Pushable for u32

unsafe fn push(self, lstate: *mut State) -> Result<i32, Error>

impl Pushable for u64

unsafe fn push(self, lstate: *mut State) -> Result<i32, Error>

impl Pushable for usize

unsafe fn push(self, lstate: *mut State) -> Result<i32, Error>

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

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

unsafe fn push(self, lstate: *mut State) -> Result<i32, Error>

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

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

unsafe fn push(self, lstate: *mut State) -> Result<i32, Error>

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

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

unsafe fn push(self, lstate: *mut State) -> Result<i32, Error>

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

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

unsafe fn push(self, lstate: *mut State) -> Result<i32, Error>

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

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

unsafe fn push(self, lstate: *mut State) -> Result<i32, Error>

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

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

unsafe fn push(self, lstate: *mut State) -> Result<i32, Error>

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

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

unsafe fn push(self, lstate: *mut State) -> Result<i32, Error>

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

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

unsafe fn push(self, lstate: *mut State) -> Result<i32, Error>

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

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

unsafe fn push(self, lstate: *mut State) -> Result<i32, Error>

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

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

unsafe fn push(self, lstate: *mut State) -> Result<i32, Error>

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

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

unsafe fn push(self, lstate: *mut State) -> Result<i32, Error>

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

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

unsafe fn push(self, lstate: *mut State) -> Result<i32, Error>

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

where A: Pushable, B: Pushable, C: Pushable, D: Pushable,

unsafe fn push(self, lstate: *mut State) -> Result<i32, Error>

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

where A: Pushable, B: Pushable, C: Pushable,

unsafe fn push(self, lstate: *mut State) -> Result<i32, Error>

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

where A: Pushable, B: Pushable,

unsafe fn push(self, lstate: *mut State) -> Result<i32, Error>

impl<A> Pushable for (A,)

where A: Pushable,

unsafe fn push(self, lstate: *mut State) -> Result<i32, Error>

impl<T, E> Pushable for Result<T, E>

where T: Pushable, E: Display,

unsafe fn push(self, lstate: *mut State) -> Result<i32, Error>

impl<T> Pushable for Option<T>

where T: Pushable,

unsafe fn push(self, lstate: *mut State) -> Result<i32, Error>

impl<T> Pushable for Vec<T>

where T: Pushable,

unsafe fn push(self, lstate: *mut State) -> Result<i32, Error>

Implementors

impl Pushable for Array

impl Pushable for Buffer

impl Pushable for Dictionary

impl Pushable for Object

impl Pushable for nvim_oxi::String

impl Pushable for TabPage

impl Pushable for Window

impl<A, R> Pushable for Function<A, R>