Struct DefinitionBuilder 

pub struct DefinitionBuilder {
    pub entries: Vec<Entry>,
    pub queued_params: Vec<(String, String)>,
    pub queued_returns: Vec<String>,
    pub queued_doc: Option<String>,
}

Builder for definition entries

Fields

entries: Vec<Entry>

queued_params: Vec<(String, String)>

queued_returns: Vec<String>

queued_doc: Option<String>

Implementations

impl DefinitionBuilder

pub fn document(self, doc: impl Display) -> Self

Queue a doc comment for the next function call or value definition

pub fn param(self, name: impl Display, doc: impl Display) -> Self

Queue a param for the next function call

pub fn ret(self, doc: impl Display) -> Self

Queue a return for the next function call

pub fn function<Params, Returns>( self, name: impl Display, _: impl IntoTypedFunction<Params, Returns>, ) -> Self

where Params: TypedMultiValue, Returns: TypedMultiValue,

Register a definition entry that is a function type

pub fn register<T: Typed>(self, name: impl Into<Cow<'static, str>>) -> Self

Register a type

pub fn register_as( self, name: impl Into<Cow<'static, str>>, ty: impl Into<Type>, ) -> Self

Register a already built type.

pub fn value<T: Typed>(self, name: impl Display) -> Self

Register a value that is available

This can be a table, union/enum, literal, or any other value and it will be typed with the given type

Example

use mlua_extras::{typed::{generator::{Definitions, Definition}, TypedUserData, TypedDataFields}, Typed, UserData};

#[derive(UserData, Typed)]
struct Example {
    color: String
}
impl TypedUserData for Example {
    fn add_documentation<F: mlua_extras::typed::TypedDataDocumentation<Self>>(docs: &mut F) {
        docs.add("This is an example");
    }

    fn add_fields<F: TypedDataFields<Self>>(fields: &mut F) {
        fields
            .document("Example field")
            .add_field_method_get_set(
                "color",
                |_lua, this| Ok(this.color.clone()),
                |_lua, this, clr: String| {
                    this.color = clr;
                    Ok(())
                },
            );
    }
}

Definitions::start()
    .define("init", Definition::start()
        .register::<Example>("Example")
        .value::<Example>("example")
    )
    .finish();

--- init.d.lua
--- @meta

--- This is an example
--- @class Example
--- Example field
--- @field color string

--- The example module
--- @type Example
example = nil

pub fn finish(self) -> Definition

Finish the definition

Trait Implementations

impl Clone for DefinitionBuilder

fn clone(&self) -> DefinitionBuilder

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DefinitionBuilder

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

Formats the value using the given formatter.

impl Default for DefinitionBuilder

fn default() -> DefinitionBuilder

Returns the “default value” for a type.

impl From<DefinitionBuilder> for Definition

fn from(value: DefinitionBuilder) -> Self

Converts to this type from the input type.