Struct tealr::RecordGenerator

pub struct RecordGenerator {

    pub should_be_inlined: bool,
    pub is_user_data: bool,
    pub type_name: Cow<'static, [NamePart]>,
    pub fields: Vec<Field>,
    pub static_fields: Vec<Field>,
    pub methods: Vec<ExportedFunction>,
    pub mut_methods: Vec<ExportedFunction>,
    pub functions: Vec<ExportedFunction>,
    pub mut_functions: Vec<ExportedFunction>,
    pub meta_method: Vec<ExportedFunction>,
    pub meta_method_mut: Vec<ExportedFunction>,
    pub meta_function: Vec<ExportedFunction>,
    pub meta_function_mut: Vec<ExportedFunction>,
    pub documentation: HashMap<NameContainer, String>,
    pub type_doc: String,
    pub should_generate_help_method: bool,
    /* private fields */
}

contains all the information needed to create a record

Fields

should_be_inlined: bool

Represents if the type should be inlined or not.

is_user_data: bool

Represents if the type is UserData

type_name: Cow<'static, [NamePart]>

The name of the type in teal

fields: Vec<Field>

The exposed fields and their types

static_fields: Vec<Field>

The exposed static fields and their types

methods: Vec<ExportedFunction>

exported methods

mut_methods: Vec<ExportedFunction>

exported methods that mutate something

functions: Vec<ExportedFunction>

exported functions

mut_functions: Vec<ExportedFunction>

exported functions that mutate something

meta_method: Vec<ExportedFunction>

exported meta_methods

meta_method_mut: Vec<ExportedFunction>

exported meta_methods that mutate something

meta_function: Vec<ExportedFunction>

exported meta functions

meta_function_mut: Vec<ExportedFunction>

exported meta functions that mutate something

documentation: HashMap<NameContainer, String>

registered documentation

type_doc: String

documentation for this type itself

should_generate_help_method: bool

if this type needs to get a .help() function

Implementations

impl RecordGenerator

pub fn new<A: ToTypename>(should_be_inlined: bool) -> Self

creates a new RecordGenerator

Examples found in repository

examples/rlua/manual.rs (line 49)

    fn get_type_body() -> TypeGenerator {
        let mut gen = RecordGenerator::new::<Self>(false);
        gen.is_user_data = true;
        <Self as TealData>::add_methods(&mut gen);
        gen.into()
    }

examples/rlua/manual_documentation.rs (line 49)

    fn get_type_body() -> tealr::TypeGenerator {
        let mut gen = tealr::RecordGenerator::new::<Self>(false);
        gen.is_user_data = true;
        <Self as TealData>::add_methods(&mut gen);
        gen.into()
    }

examples/mlua/manual.rs (line 73)

    fn get_type_body() -> tealr::TypeGenerator {
        let mut gen = tealr::RecordGenerator::new::<Self>(false);
        gen.is_user_data = true;
        <Self as TealData>::add_fields(&mut gen);
        <Self as TealData>::add_methods(&mut gen);
        gen.into()
    }

examples/mlua/manual_documentation.rs (line 85)

    fn get_type_body() -> tealr::TypeGenerator {
        let mut gen = tealr::RecordGenerator::new::<Self>(false);
        gen.is_user_data = true;
        <Self as TealData>::add_fields(&mut gen);
        <Self as TealData>::add_methods(&mut gen);
        gen.into()
    }

impl RecordGenerator

pub fn copy_docs(&mut self, to: &[u8])

copies the documentation stored in “next_docs” to be linked to the given name Shouldn’t be called manually unless you add the fields/methods by hand rather than using the functions for this.

pub fn document(&mut self, documentation: &str)

adds documentation to the next field.

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

adds documentation to the type itself

Trait Implementations

impl Clone for RecordGenerator

fn clone(&self) -> RecordGenerator

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for RecordGenerator

fn default() -> RecordGenerator

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for RecordGenerator

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Box<RecordGenerator>> for RecordGenerator

fn from(x: Box<RecordGenerator>) -> Self

Converts to this type from the input type.

impl From<RecordGenerator> for TypeGenerator

fn from(a: RecordGenerator) -> Self

Converts to this type from the input type.

impl Serialize for RecordGenerator

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'lua, T> TealDataFields<'lua, T> for RecordGenerator

where T: 'static + TealDataM + UserDataM + ToTypename,

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

where S: AsRef<str> + ?Sized, R: IntoLua<'lua> + ToTypename, M: 'static + MaybeSend + Fn(&'lua Lua, &T) -> Result<R>,

the teal version of UserDataFields

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

where S: AsRef<str> + ?Sized, A: FromLua<'lua> + ToTypename, M: 'static + MaybeSend + FnMut(&'lua Lua, &mut T, A) -> Result<()>,

the teal version of UserDataFields

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

where S: AsRef<str> + ?Sized, R: IntoLua<'lua> + ToTypename, F: 'static + MaybeSend + Fn(&'lua Lua, AnyUserData<'lua>) -> Result<R>,

the teal version of UserDataFields

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

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

the teal version of UserDataFields

fn add_meta_field_with<R, F>(&mut self, meta: MetaMethodM, _: F)

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

the teal version of UserDataFields

fn document(&mut self, documentation: &str)

Adds documentation to the next field that gets added

impl<'lua, T> TealDataMethods<'lua, T> for RecordGenerator

where T: 'static + TealDataM + UserDataM + ToTypename,

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

where S: ?Sized + AsRef<str>, A: FromLuaMultiM<'lua> + TealMultiValue, R: ToLuaMultiM<'lua> + TealMultiValue, M: 'static + MaybeSend + Fn(&'lua Lua, &T, A) -> ResultM<R>,

Exposes a method to lua

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

where S: ?Sized + AsRef<str>, A: FromLuaMultiM<'lua> + TealMultiValue, R: ToLuaMultiM<'lua> + TealMultiValue, M: 'static + MaybeSend + FnMut(&'lua Lua, &mut T, A) -> ResultM<R>,

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

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

where S: ?Sized + AsRef<str>, A: FromLuaMultiM<'lua> + TealMultiValue, R: ToLuaMultiM<'lua> + TealMultiValue, F: 'static + MaybeSend + Fn(&'lua Lua, A) -> ResultM<R>,

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

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

where S: ?Sized + AsRef<str>, A: FromLuaMultiM<'lua> + TealMultiValue, R: ToLuaMultiM<'lua> + TealMultiValue, F: 'static + MaybeSend + FnMut(&'lua Lua, A) -> ResultM<R>,

Exposes a mutable function to lua

fn add_meta_method<A, R, M>(&mut self, name: MetaMethodM, _: M)

where A: FromLuaMultiM<'lua> + TealMultiValue, R: ToLuaMultiM<'lua> + TealMultiValue, M: 'static + MaybeSend + Fn(&'lua Lua, &T, A) -> ResultM<R>,

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

fn add_meta_method_mut<A, R, M>(&mut self, name: MetaMethodM, _: M)

where A: FromLuaMultiM<'lua> + TealMultiValue, R: ToLuaMultiM<'lua> + TealMultiValue, M: 'static + MaybeSend + FnMut(&'lua Lua, &mut T, A) -> ResultM<R>,

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

fn add_meta_function<A, R, F>(&mut self, name: MetaMethodM, _: F)

where A: FromLuaMultiM<'lua> + TealMultiValue, R: ToLuaMultiM<'lua> + TealMultiValue, F: 'static + MaybeSend + Fn(&'lua Lua, A) -> ResultM<R>,

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

fn add_meta_function_mut<A, R, F>(&mut self, name: MetaMethodM, _: F)

where A: FromLuaMultiM<'lua> + TealMultiValue, R: ToLuaMultiM<'lua> + TealMultiValue, F: 'static + MaybeSend + FnMut(&'lua Lua, A) -> ResultM<R>,

Exposes a meta and mutable function 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: FromLuaMultiM<'lua> + TealMultiValue, MR: Future<Output = ResultM<R>> + 's, R: ToLuaMultiM<'lua> + TealMultiValue, 'lua: 's,

exposes an async method to lua

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

where S: AsRef<str> + ?Sized, A: FromLuaMultiM<'lua> + TealMultiValue, R: ToLuaMultiM<'lua> + TealMultiValue, F: 'static + MaybeSend + Fn(&'lua Lua, A) -> FR, FR: 'lua + Future<Output = ResultM<R>>,

exposes an async function to lua

fn generate_help(&mut self)

generates a .help() function on lua’s/teals side, which can be used at run time to view the documentation.

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

Adds documentation to the next method/function that gets added

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

Adds documentation for this type itself. They will be written right above the record in the .d.tl file

impl<'lua, T> TealDataMethods<'lua, T> for RecordGenerator

where T: 'static + TealDataR + UserDataR + ToTypename,

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

where S: ?Sized + AsRef<str>, A: FromLuaMultiR<'lua> + TealMultiValue, R: ToLuaMultiR<'lua> + TealMultiValue, M: 'static + Send + Fn(Context<'lua>, &T, A) -> ResultR<R>,

Exposes a method to lua

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

where S: ?Sized + AsRef<str>, A: FromLuaMultiR<'lua> + TealMultiValue, R: ToLuaMultiR<'lua> + TealMultiValue, M: 'static + Send + FnMut(Context<'lua>, &mut T, A) -> ResultR<R>,

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

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

where S: ?Sized + AsRef<str>, A: FromLuaMultiR<'lua> + TealMultiValue, R: ToLuaMultiR<'lua> + TealMultiValue, F: 'static + Send + Fn(Context<'lua>, A) -> ResultR<R>,

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

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

where S: ?Sized + AsRef<str>, A: FromLuaMultiR<'lua> + TealMultiValue, R: ToLuaMultiR<'lua> + TealMultiValue, F: 'static + Send + FnMut(Context<'lua>, A) -> ResultR<R>,

Exposes a mutable function to lua

fn add_meta_method<A, R, M>(&mut self, name: MetaMethodR, _: M)

where A: FromLuaMultiR<'lua> + TealMultiValue, R: ToLuaMultiR<'lua> + TealMultiValue, M: 'static + Send + Fn(Context<'lua>, &T, A) -> ResultR<R>,

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

fn add_meta_method_mut<A, R, M>(&mut self, name: MetaMethodR, _: M)

where A: FromLuaMultiR<'lua> + TealMultiValue, R: ToLuaMultiR<'lua> + TealMultiValue, M: 'static + Send + FnMut(Context<'lua>, &mut T, A) -> ResultR<R>,

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

fn add_meta_function<A, R, F>(&mut self, name: MetaMethodR, _: F)

where A: FromLuaMultiR<'lua> + TealMultiValue, R: ToLuaMultiR<'lua> + TealMultiValue, F: 'static + Send + Fn(Context<'lua>, A) -> ResultR<R>,

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

fn add_meta_function_mut<A, R, F>(&mut self, name: MetaMethodR, _: F)

where A: FromLuaMultiR<'lua> + TealMultiValue, R: ToLuaMultiR<'lua> + TealMultiValue, F: 'static + Send + FnMut(Context<'lua>, A) -> ResultR<R>,

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

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

Adds documentation to the next method/function that gets added

fn generate_help(&mut self)

generates an instance.help() function on lua’s/teals side, which can be used at run time to view the documentation.

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

Adds documentation for this type itself. They will be written right above the record in the .d.tl file