Trait nvim_oxi::lua::Pushable

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

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

Required Methods

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

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

Implementations on Foreign Types

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 lua_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 lua_State) -> Result<i32, Error>

impl Pushable for u64

unsafe fn push(self, lstate: *mut lua_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 lua_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 lua_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 lua_State) -> Result<i32, Error>

impl Pushable for i32

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

impl<T> Pushable for Option<T>where
    T: Pushable,

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

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

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

impl Pushable for usize

unsafe fn push(self, lstate: *mut lua_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 lua_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 lua_State) -> Result<i32, Error>

impl Pushable for ()

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

impl Pushable for u8

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

impl Pushable for f32

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

impl<T> Pushable for Vec<T, Global>where
    T: Pushable,

unsafe fn push(self, lstate: *mut lua_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 lua_State) -> Result<i32, Error>

impl Pushable for f64

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

impl<A> Pushable for (A,)where
    A: Pushable,

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

impl Pushable for String

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

impl Pushable for i8

unsafe fn push(self, lstate: *mut lua_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 lua_State) -> Result<i32, Error>

impl Pushable for u16

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

impl Pushable for u32

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

impl Pushable for i16

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

impl Pushable for isize

unsafe fn push(self, lstate: *mut lua_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 lua_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 lua_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 lua_State) -> Result<i32, Error>

impl Pushable for bool

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

impl Pushable for i64

unsafe fn push(self, lstate: *mut lua_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 lua_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 lua_State) -> Result<i32, Error>

Implementors

impl Pushable for Buffer

impl Pushable for TabPage

impl Pushable for Window

impl Pushable for KVec<KeyValuePair>

impl Pushable for KVec<Object>

impl Pushable for Object

impl Pushable for nvim_oxi::String

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