Trait UserDataMethods 

pub trait UserDataMethods<T> {
    // Required methods
    fn add_method<M, A, R>(&mut self, name: impl Into<StdString>, method: M)
       where M: Fn(&Lua, &T, A) -> Result<R> + MaybeSend + 'static,
             A: FromLuaMulti,
             R: IntoLuaMulti;
    fn add_method_mut<M, A, R>(&mut self, name: impl Into<StdString>, method: M)
       where M: FnMut(&Lua, &mut T, A) -> Result<R> + MaybeSend + 'static,
             A: FromLuaMulti,
             R: IntoLuaMulti;
    fn add_async_method<M, A, MR, R>(
        &mut self,
        name: impl Into<StdString>,
        method: M,
    )
       where T: 'static,
             M: Fn(Lua, UserDataRef<T>, A) -> MR + MaybeSend + 'static,
             A: FromLuaMulti,
             MR: Future<Output = Result<R>> + MaybeSend + 'static,
             R: IntoLuaMulti;
    fn add_async_method_mut<M, A, MR, R>(
        &mut self,
        name: impl Into<StdString>,
        method: M,
    )
       where T: 'static,
             M: Fn(Lua, UserDataRefMut<T>, A) -> MR + MaybeSend + 'static,
             A: FromLuaMulti,
             MR: Future<Output = Result<R>> + MaybeSend + 'static,
             R: IntoLuaMulti;
    fn add_function<F, A, R>(&mut self, name: impl Into<StdString>, function: F)
       where F: Fn(&Lua, A) -> Result<R> + MaybeSend + 'static,
             A: FromLuaMulti,
             R: IntoLuaMulti;
    fn add_function_mut<F, A, R>(
        &mut self,
        name: impl Into<StdString>,
        function: F,
    )
       where F: FnMut(&Lua, A) -> Result<R> + MaybeSend + 'static,
             A: FromLuaMulti,
             R: IntoLuaMulti;
    fn add_async_function<F, A, FR, R>(
        &mut self,
        name: impl Into<StdString>,
        function: F,
    )
       where F: Fn(Lua, A) -> FR + MaybeSend + 'static,
             A: FromLuaMulti,
             FR: Future<Output = Result<R>> + MaybeSend + 'static,
             R: IntoLuaMulti;
    fn add_meta_method<M, A, R>(
        &mut self,
        name: impl Into<StdString>,
        method: M,
    )
       where M: Fn(&Lua, &T, A) -> Result<R> + MaybeSend + 'static,
             A: FromLuaMulti,
             R: IntoLuaMulti;
    fn add_meta_method_mut<M, A, R>(
        &mut self,
        name: impl Into<StdString>,
        method: M,
    )
       where M: FnMut(&Lua, &mut T, A) -> Result<R> + MaybeSend + 'static,
             A: FromLuaMulti,
             R: IntoLuaMulti;
    fn add_async_meta_method<M, A, MR, R>(
        &mut self,
        name: impl Into<StdString>,
        method: M,
    )
       where T: 'static,
             M: Fn(Lua, UserDataRef<T>, A) -> MR + MaybeSend + 'static,
             A: FromLuaMulti,
             MR: Future<Output = Result<R>> + MaybeSend + 'static,
             R: IntoLuaMulti;
    fn add_async_meta_method_mut<M, A, MR, R>(
        &mut self,
        name: impl Into<StdString>,
        method: M,
    )
       where T: 'static,
             M: Fn(Lua, UserDataRefMut<T>, A) -> MR + MaybeSend + 'static,
             A: FromLuaMulti,
             MR: Future<Output = Result<R>> + MaybeSend + 'static,
             R: IntoLuaMulti;
    fn add_meta_function<F, A, R>(
        &mut self,
        name: impl Into<StdString>,
        function: F,
    )
       where F: Fn(&Lua, A) -> Result<R> + MaybeSend + 'static,
             A: FromLuaMulti,
             R: IntoLuaMulti;
    fn add_meta_function_mut<F, A, R>(
        &mut self,
        name: impl Into<StdString>,
        function: F,
    )
       where F: FnMut(&Lua, A) -> Result<R> + MaybeSend + 'static,
             A: FromLuaMulti,
             R: IntoLuaMulti;
    fn add_async_meta_function<F, A, FR, R>(
        &mut self,
        name: impl Into<StdString>,
        function: F,
    )
       where F: Fn(Lua, A) -> FR + MaybeSend + 'static,
             A: FromLuaMulti,
             FR: Future<Output = Result<R>> + MaybeSend + 'static,
             R: IntoLuaMulti;
}

Method registry for UserData implementors.

Required Methods

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

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

Add a regular method which accepts a &T as the first parameter.

Regular methods are implemented by overriding the __index metamethod and returning the accessed method. This allows them to be used with the expected userdata:method() syntax.

If add_meta_method is used to set the __index metamethod, the __index metamethod will be used as a fall-back if no regular method is found.

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

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

Add a regular method which accepts a &mut T as the first parameter.

Refer to add_method for more information about the implementation.

fn add_async_method<M, A, MR, R>( &mut self, name: impl Into<StdString>, method: M, )

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

Available on crate feature async only.

Add an async method which accepts a &T as the first parameter and returns Future.

Refer to add_method for more information about the implementation.

fn add_async_method_mut<M, A, MR, R>( &mut self, name: impl Into<StdString>, method: M, )

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

Available on crate feature async only.

Add an async method which accepts a &mut T as the first parameter and returns Future.

Refer to add_method for more information about the implementation.

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

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

Add a regular method as a function which accepts generic arguments.

The first argument will be a AnyUserData of type T if the method is called with Lua method syntax: my_userdata:my_method(arg1, arg2), or it is passed in as the first argument: my_userdata.my_method(my_userdata, arg1, arg2).

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

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

Add a regular method as a mutable function which accepts generic arguments.

This is a version of add_function that accepts a FnMut argument.

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

where F: Fn(Lua, A) -> FR + MaybeSend + 'static, A: FromLuaMulti, FR: Future<Output = Result<R>> + MaybeSend + 'static, R: IntoLuaMulti,

Available on crate feature async only.

Add a regular method as an async function which accepts generic arguments and returns Future.

This is an async version of add_function.

fn add_meta_method<M, A, R>(&mut self, name: impl Into<StdString>, method: M)

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

Add a metamethod which accepts a &T as the first parameter.

Note

This can cause an error with certain binary metamethods that can trigger if only the right side has a metatable. To prevent this, use add_meta_function.

fn add_meta_method_mut<M, A, R>( &mut self, name: impl Into<StdString>, method: M, )

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

Add a metamethod as a function which accepts a &mut T as the first parameter.

Note

This can cause an error with certain binary metamethods that can trigger if only the right side has a metatable. To prevent this, use add_meta_function.

fn add_async_meta_method<M, A, MR, R>( &mut self, name: impl Into<StdString>, method: M, )

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

Available on crate feature async and neither crate feature lua51 nor crate feature luau only.

Add an async metamethod which accepts a &T as the first parameter and returns Future.

This is an async version of add_meta_method.

fn add_async_meta_method_mut<M, A, MR, R>( &mut self, name: impl Into<StdString>, method: M, )

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

Available on crate feature async only.

Add an async metamethod which accepts a &mut T as the first parameter and returns Future.

This is an async version of add_meta_method_mut.

fn add_meta_function<F, A, R>( &mut self, name: impl Into<StdString>, function: F, )

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

Add a metamethod which accepts generic arguments.

Metamethods for binary operators can be triggered if either the left or right argument to the binary operator has a metatable, so the first argument here is not necessarily a userdata of type T.

fn add_meta_function_mut<F, A, R>( &mut self, name: impl Into<StdString>, function: F, )

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

Add a metamethod as a mutable function which accepts generic arguments.

This is a version of add_meta_function that accepts a FnMut argument.

fn add_async_meta_function<F, A, FR, R>( &mut self, name: impl Into<StdString>, function: F, )

where F: Fn(Lua, A) -> FR + MaybeSend + 'static, A: FromLuaMulti, FR: Future<Output = Result<R>> + MaybeSend + 'static, R: IntoLuaMulti,

Available on crate feature async and neither crate feature lua51 nor crate feature luau only.

Add a metamethod which accepts generic arguments and returns Future.

This is an async version of add_meta_function.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<T> UserDataMethods<T> for UserDataRegistry<T>