Attribute Macro user_data_impl 

#[user_data_impl]

Attribute macro that registers methods from an impl block for use in Lua.

Used on an impl block for a type that derives UserData, this macro will register methods annotated with #[method], #[metamethod(...)], #[getter(...)], #[setter(...)], and #[field] along with const expressions with or without #[field].

Attributes

• #[method]
  • #[method(rename = "name"): register as a method with the provided name
• #[metamethod(...)]
  • #[metamethod(ToString)]: register as a metamethod as a [mlua::MetaMethod] variant
  • #[metamethod("__custom")]: register as a custom named metamethod
• #[getter(...)]
  • #[getter("field")]: register the function as a getter for the named field
• #[setter(...)]
  • #[setter("field")]: register the function as a setter for the named field
• #[field(...)]
  • Applied to a function will call the function once to register a static field
  • Applied to a const expr will register the value as a static field
  • #[field(rename="field")]: register field with the custom name
  • #[field(skip)]: ignore the function or const expr and don’t register it

Patterns

• &self: registered with mlua::UserDataMethods::add_method or mlua::UserDataMethods::add_meta_method
• &mut self: registered with mlua::UserDataMethods::add_method_mut or mlua::UserDataMethods::add_meta_method_mut
• without self: registered with mlua::UserDataMethods::add_function or mlua::UserDataMethods::add_meta_function
• async fn: registered with the mlua::UserDataMethods::add_async_* variant that matches the above arguments
• If the first non self parameter is lua then &mlua::Lua is passed to non async methods/functions and mlua::Lua is passed into async methods/functions

Return

• Result<T, E> where E: Into<mlua::Error>: Method is fallible and the error is automatically converted to a [mlua::Error]. This includes any error type that implements [mlua::ExternalError] and any return type that has the name Result.
• T: Method is infallible and is wrapped with Ok(...) when registered
• (): Method is infallible and has no return value. Registration returns Ok(())

All methods stay as is and stay as regular callable rust functions. Any methods without one of the listed attribute macros will not be registered.

Example

#[derive(Clone, TypedUserData)]
struct Counter { value: i64 }
 
#[typed_user_data_impl]
impl Counter {
    const COUNT: usize = 10;
 
    #[field]
    fn max() -> i64 {
        i64::MAX
    }
 
    #[field(rename = "MIN")]
    fn min() -> i64 {
        0
    }
 
    #[getter("direction")]
    fn get_direction(&self) -> String {
        "west".into()
    }
 
    #[setter("direction")]
    fn set_direction(&mut self, dir: String) {
        _ = dir;
    }
 
    #[method]
    fn get(&self) -> i64 { self.value }
 
    #[method]
    fn increment(&mut self) { self.value += 1 }
 
    #[method]
    fn create_table(&self, lua: &mlua::Lua) -> mlua::Result<mlua::Table> {
        lua.create_table()
    }
 
    #[metamethod(ToString)]
    fn to_string(&self) -> String { format!("Counter({})", self.value) }
 
    // Requires the `async` feature
    // Must be accessed from lua code with an entry of `mlua::Chunk::eval_async` or `mlua::Chunk::exec_async`
    #[method]
    async fn fetch(&self, lua: mlua::Lua, url: String) -> mlua::Result<String> {
        _ = lua;
        Ok(format!("fetched: {url}"))
    }
}