Struct TypedClassBuilder

pub struct TypedClassBuilder {
    pub type_doc: Option<Cow<'static, str>>,
    pub fields: BTreeMap<Cow<'static, str>, Field>,
    pub static_fields: BTreeMap<Cow<'static, str>, Field>,
    pub meta_fields: BTreeMap<Cow<'static, str>, Field>,
    pub methods: BTreeMap<Cow<'static, str>, Func>,
    pub meta_methods: BTreeMap<Cow<'static, str>, Func>,
    pub functions: BTreeMap<Cow<'static, str>, Func>,
    pub meta_functions: BTreeMap<Cow<'static, str>, Func>,
    /* private fields */
}

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

Fields

type_doc: Option<Cow<'static, str>>

fields: BTreeMap<Cow<'static, str>, Field>

static_fields: BTreeMap<Cow<'static, str>, Field>

meta_fields: BTreeMap<Cow<'static, str>, Field>

methods: BTreeMap<Cow<'static, str>, Func>

meta_methods: BTreeMap<Cow<'static, str>, Func>

functions: BTreeMap<Cow<'static, str>, Func>

meta_functions: BTreeMap<Cow<'static, str>, Func>

Implementations

impl TypedClassBuilder

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

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 Ord for TypedClassBuilder

fn cmp(&self, other: &TypedClassBuilder) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for TypedClassBuilder

fn eq(&self, other: &TypedClassBuilder) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for TypedClassBuilder

fn partial_cmp(&self, other: &TypedClassBuilder) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'lua, T: TypedUserData> TypedDataFields<'lua, T> for TypedClassBuilder

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

Adds documentation to the next field that gets added

fn add_field<V>(&mut self, name: impl AsRef<str>, _: V)

where V: IntoLua<'lua> + Clone + 'static + Typed,

Typed version of add_field

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

where S: AsRef<str> + ?Sized, A: FromLua<'lua> + Typed, F: 'static + MaybeSend + FnMut(&'lua Lua, AnyUserData<'lua>, A) -> Result<()>,

Typed version of add_field_function_set

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

where S: AsRef<str> + ?Sized, R: IntoLua<'lua> + Typed, F: 'static + MaybeSend + Fn(&'lua Lua, AnyUserData<'lua>) -> 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: AsRef<str> + ?Sized, R: IntoLua<'lua> + Typed, A: FromLua<'lua> + Typed, GET: 'static + MaybeSend + Fn(&'lua Lua, AnyUserData<'lua>) -> Result<R>, SET: 'static + MaybeSend + Fn(&'lua Lua, AnyUserData<'lua>, 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: AsRef<str> + ?Sized, A: FromLua<'lua> + Typed, M: 'static + MaybeSend + FnMut(&'lua 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: AsRef<str> + ?Sized, R: IntoLua<'lua> + Typed, M: 'static + MaybeSend + Fn(&'lua 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: AsRef<str> + ?Sized, R: IntoLua<'lua> + Typed, A: FromLua<'lua> + Typed, GET: 'static + MaybeSend + Fn(&'lua Lua, &T) -> Result<R>, SET: 'static + MaybeSend + Fn(&'lua Lua, &mut T, A) -> Result<()>,

Typed version of add_field_method_get and add_field_method_set combined

fn add_meta_field<R, F>(&mut self, meta: MetaMethod, _: F)

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

Typed version of add_meta_field

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

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

Adds documentation to the next method/function that gets added

fn add_method<S, A, R, M>(&mut self, name: &S, _: 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_with<S, A, R, M, G>(&mut self, name: &S, _method: M, generator: G)

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

Exposes a method to lua

fn add_function<S, A, R, F>(&mut self, name: &S, _: 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_with<S, A, R, F, G>( &mut self, name: &S, _function: F, generator: G, )

where S: ?Sized + AsRef<str>, A: FromLuaMulti<'lua> + TypedMultiValue, R: IntoLuaMulti<'lua> + TypedMultiValue, F: 'static + MaybeSend + Fn(&'lua Lua, A) -> Result<R>, G: Fn(&mut FunctionBuilder<A, 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: ?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_method_mut_with<S, A, R, M, G>( &mut self, name: &S, _method: M, generator: G, )

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

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

fn add_meta_method<A, R, M>(&mut self, meta: MetaMethod, _: 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_with<A, R, M, G>( &mut self, meta: MetaMethod, _method: M, generator: G, )

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

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

fn add_async_method<'s, S: ?Sized + AsRef<str>, A, R, M, MR>( &mut self, name: &S, _: 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_async_method_with<'s, S: ?Sized + AsRef<str>, A, R, M, MR, G>( &mut self, name: &S, _method: M, generator: G, )

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, G: Fn(&mut FunctionBuilder<A, R>), 'lua: 's,

exposes an async method to lua

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

where T: 'static, M: Fn(&'lua Lua, &'s mut 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_async_method_mut_with<'s, S: ?Sized + AsRef<str>, A, R, M, MR, G>( &mut self, name: &S, _method: M, generator: G, )

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

exposes an async method to lua

fn add_function_mut<S, A, R, F>(&mut self, name: &S, _: 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_function_mut_with<S, A, R, F, G>( &mut self, name: &S, _function: F, generator: G, )

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

Exposes a mutable function to lua

fn add_meta_function<A, R, F>(&mut self, meta: MetaMethod, _: 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_with<A, R, F, G>( &mut self, meta: MetaMethod, _function: F, generator: G, )

where A: FromLuaMulti<'lua> + TypedMultiValue, R: IntoLuaMulti<'lua> + TypedMultiValue, F: 'static + MaybeSend + Fn(&'lua Lua, A) -> Result<R>, G: Fn(&mut FunctionBuilder<A, 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: 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_async_function_with<S, A, R, F, FR, G>( &mut self, name: &S, _function: F, generator: G, )

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>>, G: Fn(&mut FunctionBuilder<A, R>),

exposes an async function to lua

fn add_meta_method_mut<A, R, M>(&mut self, meta: MetaMethod, _: 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_method_mut_with<A, R, M, G>( &mut self, meta: MetaMethod, _method: M, generator: G, )

where A: FromLuaMulti<'lua> + TypedMultiValue, R: IntoLuaMulti<'lua> + TypedMultiValue, M: 'static + MaybeSend + FnMut(&'lua Lua, &mut T, A) -> Result<R>, G: Fn(&mut FunctionBuilder<A, 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: MetaMethod, _: 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 add_meta_function_mut_with<A, R, F, G>( &mut self, meta: MetaMethod, _function: F, generator: G, )

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

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

impl Eq for TypedClassBuilder

impl StructuralPartialEq for TypedClassBuilder