rtk-lua 0.1.0

The Lua engine for Rust Type Kit - query Rust types and produce FFI types
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

/// Implements `IntoLua` for a struct.
///
/// ```rust,ignore
/// impl_into_lua! {
///     FunctionTypeValue {
///         location,
///         args_struct,
///         // closure will apply to whatever the field name itself is
///         return_type => return_type.map(|b| *b),
///         item_id,
///     }
/// }
/// ```
#[macro_export]
macro_rules! impl_into_lua {
    (
        $ty:ty {
            $( $field:ident $(=> $conv:expr)? ),* $(,)?
        }
    ) => {
        impl IntoLua for $ty {
            fn into_lua(self, lua: &::mlua::Lua) -> ::mlua::Result<::mlua::Value> {
                let Self { $( $field ),* } = self;

                let table = lua.create_table()?;

                $(
                    impl_into_lua!(@assign table $field $(=> $conv)?);
                )*

                Ok(::mlua::Value::Table(table))
            }
        }
    };

    (@assign $tbl:ident $field:ident) => {
        $tbl.set(stringify!($field), $field)?;
    };

    (@assign $tbl:ident $field:ident => $conv:expr) => {
        $tbl.set(stringify!($field), $conv)?;
    };
}

/// Implements `IntoLua` for enums by mapping each variant to a Lua table formed like
/// `{ variant_name, variant_data }`
///
/// ```rust,ignore
/// #[derive(Clone, Debug)]
/// pub enum MyValue {
///     Nil,
///     Str(String),
/// }
///
/// impl_enum_into_lua! {
///     MyValue {
///         Nil,
///         // this will just forward the one tuple variant forwards
///         Str(s) => s,
///     }
/// }
/// ```
#[macro_export]
macro_rules! impl_enum_into_lua {
    (
        $enum:ident {
            $(
                $name:ident
                    $( ( $($tuple_pat:pat),* ) )?
                    $( { $($struct_pat:pat),* } )?
                    $( => $data:expr )?
            ),* $(,)?
        }
    ) => {
        impl ::mlua::IntoLua for $enum {
            fn into_lua(self, lua: &::mlua::Lua) -> ::mlua::Result<::mlua::Value> {
                match self {
                    $(
                        $enum::$name
                            $( ( $($tuple_pat),* ) )?
                            $( { $($struct_pat),* } )?
                            => {
                                let tbl = lua.create_table()?;
                                tbl.set("variant_name", stringify!($name))?;
                                tbl.set(
                                    "variant_data",
                                    impl_enum_into_lua!(@value lua $(, $data)?)
                                )?;
                                Ok(::mlua::Value::Table(tbl))
                            }
                    ),*
                }
            }
        }
    };

    (@value $lua:ident , $val:expr) => { $val };
    (@value $lua:ident) => { ::mlua::Value::Nil };
}