Struct TypedClassBuilder 

pub struct TypedClassBuilder {
    pub typed_class: TypedClass,
    /* private fields */
}

Type information for a lua class. This happens to be a TypedUserData

Fields

typed_class: TypedClass

Implementations

impl TypedClassBuilder

pub fn new<T: TypedUserData>() -> Self

pub fn build(self) -> TypedClass

pub fn skip_field(self, idx: impl Into<Index>) -> Self

Skip/Remove a field field from the class definition

pub fn skip_method(self, idx: impl Into<Index>) -> Self

Skip/Remove a method from the class definition

pub fn skip_meta_method(self, idx: impl Into<Index>) -> Self

Skip/Remove a meta method from the class definition

pub fn skip_function(self, idx: impl Into<Index>) -> Self

Skip/Remove a function from the class definition

pub fn skip_meta_function(self, idx: impl Into<Index>) -> Self

Skip/Remove a meta function from the class definition

pub fn field( self, key: impl Into<Index>, ty: Type, doc: impl IntoDocComment, ) -> Self

Creates a new typed field and adds it to the class’s type information

Example

use mlua_extras::typed::{TypedClassBuilder, Type};

static NAME: &str = "mlua_extras";

TypedClassBuilder::default()
    .field("data1", Type::string() | Type::nil(), "doc comment goes last")
    .field("data2", Type::array(Type::string()), ()) // Can also use `None` instead of `()`
    .field("message", Type::string(), format!("A message for {NAME}"));

pub fn static_field<V>( self, key: impl Into<Index>, value: V, doc: impl IntoDocComment, ) -> Self

where V: Typed + IntoLua,

pub fn inherit(self, parent: &TypedClass) -> Self

pub fn function<Params, Returns>( self, key: impl Into<Index>, doc: impl IntoDocComment, ) -> Self

where Params: TypedMultiValue, Returns: TypedMultiValue,

Creates a new typed function and adds it to the class’s type information

Example

use mlua_extras::typed::{TypedClassBuilder, Type};

TypedClassBuilder::default()
    .function::<String, ()>("greet", "Greet the given name")
    // Can use `None` instead of `()` for specifying the doc comment
    .function::<String, ()>("hello", ());

pub fn method<Params, Returns>( self, key: impl Into<Index>, doc: impl IntoDocComment, ) -> Self

where Params: TypedMultiValue, Returns: TypedMultiValue,

Creates a new typed method and adds it to the class’s type information.

As with methods in lua, the self parameter is implicit and has the same type as the parent class.

Example

use mlua_extras::typed::{TypedClassBuilder, Type};

TypedClassBuilder::default()
    .method::<String, ()>("greet", "Greet the given name")
    // Can use `None` instead of `()` for specifying the doc comment
    .method::<String, ()>("hello", ());

pub fn meta_field( self, key: impl Into<Index>, ty: Type, doc: impl IntoDocComment, ) -> Self

Creates a new typed field and adds it to the class’s meta type information

Example

use mlua_extras::typed::{TypedClassBuilder, Type};

static NAME: &str = "mlua_extras";

TypedClassBuilder::default()
    .meta_field("data1", Type::string() | Type::nil(), "doc comment goes last")
    .meta_field("data2", Type::array(Type::string()), ()) // Can also use `None` instead of `()`
    .meta_field("message", Type::string(), format!("A message for {NAME}"));

pub fn meta_function<Params, Returns>( self, key: impl Into<Index>, doc: impl IntoDocComment, ) -> Self

where Params: TypedMultiValue, Returns: TypedMultiValue,

Creates a new typed function and adds it to the class’s meta type information

Example

use mlua_extras::typed::{TypedClassBuilder, Type};

TypedClassBuilder::default()
    .meta_function::<String, ()>("greet", "Greet the given name")
    // Can use `None` instead of `()` for specifying the doc comment
    .meta_function::<String, ()>("hello", ());

pub fn meta_method<Params, Returns>( self, key: impl Into<Index>, doc: impl IntoDocComment, ) -> Self

where Params: TypedMultiValue, Returns: TypedMultiValue,

Creates a new typed method and adds it to the class’s type information.

As with methods in lua, the self parameter is implicit and has the same type as the parent class.

Example

use mlua_extras::typed::{TypedClassBuilder, Type};

static NAME: &str = "mlua_extras";

TypedClassBuilder::default()
    .method::<String, ()>("greet", "Greet the given name")
    // Can use `None` instead of `()` for specifying the doc comment
    .method::<String, ()>("hello", ());

pub fn derive(self, parent: impl Display) -> Self

Add a child class that this class derives

Trait Implementations

impl Clone for TypedClassBuilder

fn clone(&self) -> TypedClassBuilder

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TypedClassBuilder

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for TypedClassBuilder

fn default() -> TypedClassBuilder

Returns the “default value” for a type.

impl From<TypedClassBuilder> for Type

fn from(value: TypedClassBuilder) -> Self

Converts to this type from the input type.

impl<T: TypedUserData> TypedDataDocumentation<T> for TypedClassBuilder

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

impl<T: TypedUserData> TypedDataFields<T> for TypedClassBuilder

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

Adds documentation to the next field that gets added

fn coerce(&mut self, ty: impl Into<Type>) -> &mut Self

Adds a type to the queued overrides.

fn add_field<V>(&mut self, name: impl Into<String>, value: V)

where V: IntoLua + Clone + 'static + Typed,

Typed version of add_field

fn add_field_function_set<S, A, F>(&mut self, name: S, _: F)

where S: Into<String>, A: FromLua + Typed, F: 'static + MaybeSend + FnMut(&Lua, AnyUserData, A) -> Result<()>,

Typed version of add_field_function_set

fn add_field_function_get<S, R, F>(&mut self, name: S, _: F)

where S: Into<String>, R: IntoLua + Typed, F: 'static + MaybeSend + Fn(&Lua, AnyUserData) -> Result<R>,

Typed version of add_field_function_get

fn add_field_function_get_set<S, R, A, GET, SET>( &mut self, name: S, _: GET, _: SET, )

where S: Into<String>, R: IntoLua + Typed, A: FromLua + Typed, GET: 'static + MaybeSend + Fn(&Lua, AnyUserData) -> Result<R>, SET: 'static + MaybeSend + Fn(&Lua, AnyUserData, A) -> Result<()>,

Typed version of add_field_function_get and add_field_function_set combined

fn add_field_method_set<S, A, M>(&mut self, name: S, _: M)

where S: Into<String>, A: FromLua + Typed, M: 'static + MaybeSend + FnMut(&Lua, &mut T, A) -> Result<()>,

Typed version of dd_field_method_set

fn add_field_method_get<S, R, M>(&mut self, name: S, _: M)

where S: Into<String>, R: IntoLua + Typed, M: 'static + MaybeSend + Fn(&Lua, &T) -> Result<R>,

Typed version of add_field_method_get

fn add_field_method_get_set<S, R, A, GET, SET>( &mut self, name: S, _: GET, _: SET, )

where S: Into<String>, R: IntoLua + Typed, A: FromLua + Typed, GET: 'static + MaybeSend + Fn(&Lua, &T) -> Result<R>, SET: 'static + MaybeSend + Fn(&Lua, &mut T, A) -> Result<()>,

Typed version of add_field_method_get and add_field_method_set combined

fn add_meta_field<V>(&mut self, meta: impl Into<String>, value: V)

where V: IntoLua + Typed + 'static,

Typed version of add_meta_field

fn add_meta_field_with<R, F>(&mut self, meta: impl Into<String>, _: F)

where F: 'static + MaybeSend + Fn(&Lua) -> Result<R>, R: IntoLua + Typed,

Typed version of add_meta_field

impl<T: TypedUserData> TypedDataMethods<T> for TypedClassBuilder

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

Adds documentation to the next method/function that gets added

fn param(&mut self, name: impl Display, doc: impl IntoDocComment) -> &mut Self

Adds a param name and doc comment to the next method/function that gets added.

fn param_as( &mut self, ty: impl Into<Type>, name: impl Display, doc: impl IntoDocComment, ) -> &mut Self

Adds a param name and doc comment to the next method/function that gets added. Will also add an override type to the param.

fn ret(&mut self, doc: impl IntoDocComment) -> &mut Self

Adds a return doc comment to the next method/function that gets added.

fn ret_as(&mut self, ty: impl Into<Type>, doc: impl IntoDocComment) -> &mut Self

Adds a return doc comment to the next method/function that gets added. Will also add an override type to the return.

fn index<I: Typed>(&mut self, idx: isize, doc: impl IntoDocComment) -> &mut Self

Adds an index field with a type and doc comment to the class definition

fn index_as( &mut self, idx: isize, ty: impl Into<Type>, doc: impl IntoDocComment, ) -> &mut Self

Adds an index field with a type and doc comment to the class definition

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

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

Exposes a method to lua

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

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

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

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

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

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

fn add_meta_method<A, R, M>(&mut self, meta: impl Into<String>, _: M)

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

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

fn add_async_method<S: Into<String>, A, R, M, MR>(&mut self, name: S, _: M)

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

exposes an async method to lua

fn add_async_method_mut<S: Into<String>, A, R, M, MR>( &mut self, name: S, _method: M, )

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

exposes an async method to lua

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

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

Exposes a mutable function to lua

fn add_meta_function<A, R, F>(&mut self, meta: impl Into<String>, _: F)

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

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

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

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

exposes an async function to lua

fn add_meta_method_mut<A, R, M>(&mut self, meta: impl Into<String>, _: M)

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

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

fn add_meta_function_mut<A, R, F>(&mut self, meta: impl Into<String>, _: F)

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

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