Trait mlua_extras::typed::TypedDataMethods

pub trait TypedDataMethods<'lua, T> {
    // Required methods
    fn add_method<S, A, R, M>(&mut self, name: &S, method: M)
       where S: ?Sized + AsRef<str>,
             A: FromLuaMulti<'lua> + TypedMultiValue,
             R: IntoLuaMulti<'lua> + TypedMultiValue,
             M: 'static + MaybeSend + Fn(&'lua Lua, &T, A) -> Result<R>;
    fn add_method_mut<S, A, R, M>(&mut self, name: &S, method: M)
       where S: ?Sized + AsRef<str>,
             A: FromLuaMulti<'lua> + TypedMultiValue,
             R: IntoLuaMulti<'lua> + TypedMultiValue,
             M: 'static + MaybeSend + FnMut(&'lua Lua, &mut T, A) -> Result<R>;
    fn add_async_method<'s, S: ?Sized + AsRef<str>, A, R, M, MR>(
        &mut self,
        name: &S,
        method: M,
    )
       where T: 'static,
             M: Fn(&'lua Lua, &'s T, A) -> MR + MaybeSend + 'static,
             A: FromLuaMulti<'lua> + TypedMultiValue,
             MR: Future<Output = Result<R>> + 's,
             R: IntoLuaMulti<'lua> + TypedMultiValue,
             'lua: 's;
    fn add_function<S, A, R, F>(&mut self, name: &S, function: F)
       where S: ?Sized + AsRef<str>,
             A: FromLuaMulti<'lua> + TypedMultiValue,
             R: IntoLuaMulti<'lua> + TypedMultiValue,
             F: 'static + MaybeSend + Fn(&'lua Lua, A) -> Result<R>;
    fn add_function_mut<S, A, R, F>(&mut self, name: &S, function: F)
       where S: ?Sized + AsRef<str>,
             A: FromLuaMulti<'lua> + TypedMultiValue,
             R: IntoLuaMulti<'lua> + TypedMultiValue,
             F: 'static + MaybeSend + FnMut(&'lua Lua, A) -> Result<R>;
    fn add_async_function<S, A, R, F, FR>(&mut self, name: &S, function: F)
       where S: AsRef<str> + ?Sized,
             A: FromLuaMulti<'lua> + TypedMultiValue,
             R: IntoLuaMulti<'lua> + TypedMultiValue,
             F: 'static + MaybeSend + Fn(&'lua Lua, A) -> FR,
             FR: 'lua + Future<Output = Result<R>>;
    fn add_meta_method<A, R, M>(&mut self, meta: MetaMethod, method: M)
       where A: FromLuaMulti<'lua> + TypedMultiValue,
             R: IntoLuaMulti<'lua> + TypedMultiValue,
             M: 'static + MaybeSend + Fn(&'lua Lua, &T, A) -> Result<R>;
    fn add_meta_method_mut<A, R, M>(&mut self, meta: MetaMethod, method: M)
       where A: FromLuaMulti<'lua> + TypedMultiValue,
             R: IntoLuaMulti<'lua> + TypedMultiValue,
             M: 'static + MaybeSend + FnMut(&'lua Lua, &mut T, A) -> Result<R>;
    fn add_meta_function<A, R, F>(&mut self, meta: MetaMethod, function: F)
       where A: FromLuaMulti<'lua> + TypedMultiValue,
             R: IntoLuaMulti<'lua> + TypedMultiValue,
             F: 'static + MaybeSend + Fn(&'lua Lua, A) -> Result<R>;
    fn add_meta_function_mut<A, R, F>(&mut self, meta: MetaMethod, function: F)
       where A: FromLuaMulti<'lua> + TypedMultiValue,
             R: IntoLuaMulti<'lua> + TypedMultiValue,
             F: 'static + MaybeSend + FnMut(&'lua Lua, A) -> Result<R>;
    fn document(&mut self, doc: &str) -> &mut Self;
}

Typed variant of UserDataFields

Required Methods

fn add_method<S, A, R, M>(&mut self, name: &S, method: M)

where S: ?Sized + AsRef<str>, A: FromLuaMulti<'lua> + TypedMultiValue, R: IntoLuaMulti<'lua> + TypedMultiValue, M: 'static + MaybeSend + Fn(&'lua Lua, &T, A) -> Result<R>,

Exposes a method to lua

fn add_method_mut<S, A, R, M>(&mut self, name: &S, method: M)

where S: ?Sized + AsRef<str>, A: FromLuaMulti<'lua> + TypedMultiValue, R: IntoLuaMulti<'lua> + TypedMultiValue, M: 'static + MaybeSend + FnMut(&'lua Lua, &mut T, A) -> Result<R>,

Exposes a method to lua that has a mutable reference to Self

fn add_async_method<'s, S: ?Sized + AsRef<str>, A, R, M, MR>( &mut self, name: &S, method: M, )

where T: 'static, M: Fn(&'lua Lua, &'s T, A) -> MR + MaybeSend + 'static, A: FromLuaMulti<'lua> + TypedMultiValue, MR: Future<Output = Result<R>> + 's, R: IntoLuaMulti<'lua> + TypedMultiValue, 'lua: 's,

exposes an async method to lua

fn add_function<S, A, R, F>(&mut self, name: &S, function: F)

where S: ?Sized + AsRef<str>, A: FromLuaMulti<'lua> + TypedMultiValue, R: IntoLuaMulti<'lua> + TypedMultiValue, F: 'static + MaybeSend + Fn(&'lua Lua, A) -> Result<R>,

Exposes a function to lua (its a method that does not take Self)

fn add_function_mut<S, A, R, F>(&mut self, name: &S, function: F)

where S: ?Sized + AsRef<str>, A: FromLuaMulti<'lua> + TypedMultiValue, R: IntoLuaMulti<'lua> + TypedMultiValue, F: 'static + MaybeSend + FnMut(&'lua Lua, A) -> Result<R>,

Exposes a mutable function to lua

fn add_async_function<S, A, R, F, FR>(&mut self, name: &S, function: F)

where S: AsRef<str> + ?Sized, A: FromLuaMulti<'lua> + TypedMultiValue, R: IntoLuaMulti<'lua> + TypedMultiValue, F: 'static + MaybeSend + Fn(&'lua Lua, A) -> FR, FR: 'lua + Future<Output = Result<R>>,

exposes an async function to lua

fn add_meta_method<A, R, M>(&mut self, meta: MetaMethod, method: M)

where A: FromLuaMulti<'lua> + TypedMultiValue, R: IntoLuaMulti<'lua> + TypedMultiValue, M: 'static + MaybeSend + Fn(&'lua Lua, &T, A) -> Result<R>,

Exposes a meta method to lua http://lua-users.org/wiki/MetatableEvents

fn add_meta_method_mut<A, R, M>(&mut self, meta: MetaMethod, method: M)

where A: FromLuaMulti<'lua> + TypedMultiValue, R: IntoLuaMulti<'lua> + TypedMultiValue, M: 'static + MaybeSend + FnMut(&'lua Lua, &mut T, A) -> Result<R>,

Exposes a meta and mutable method to lua http://lua-users.org/wiki/MetatableEvents

fn add_meta_function<A, R, F>(&mut self, meta: MetaMethod, function: F)

where A: FromLuaMulti<'lua> + TypedMultiValue, R: IntoLuaMulti<'lua> + TypedMultiValue, F: 'static + MaybeSend + Fn(&'lua Lua, A) -> Result<R>,

Exposes a meta function to lua http://lua-users.org/wiki/MetatableEvents

fn add_meta_function_mut<A, R, F>(&mut self, meta: MetaMethod, function: F)

where A: FromLuaMulti<'lua> + TypedMultiValue, R: IntoLuaMulti<'lua> + TypedMultiValue, F: 'static + MaybeSend + FnMut(&'lua Lua, A) -> Result<R>,

Exposes a meta and mutable function to lua http://lua-users.org/wiki/MetatableEvents

fn document(&mut self, doc: &str) -> &mut Self

Adds documentation to the next method/function that gets added

Object Safety

This trait is not object safe.

Implementors

impl<'lua, 'ctx, T: UserData, U: UserDataMethods<'lua, T>> TypedDataMethods<'lua, T> for WrappedGenerator<'ctx, U>

impl<'lua, T: TypedUserData> TypedDataMethods<'lua, T> for Class