ezlua 0.5.4

Ergonomic, efficient and Zero-cost rust bindings to Lua5.4
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
100
101
102
103
104
105
106
107
108
109
110
111
112

use std::path::Path;

#[derive(Debug, Default)]
struct Test {
    a: i32,
}

#[test]
fn test() {
    println!("------------- ezlua -------------");
    {
        use ezlua::prelude::*;
        use std::cell::*;

        impl UserData for Test {
            type Trans = RefCell<Self>;

            fn methods(mt: UserdataRegistry<Self>) -> LuaResult<()> {
                mt.set_closure("inc", |mut this: RefMut<Self>| this.a += 1)?;
                Ok(())
            }

            fn getter(fields: UserdataRegistry<Self>) -> LuaResult<()> {
                fields.set_closure("a", |this: Ref<Self>| this.a)?;
                Ok(())
            }

            fn setter(fields: UserdataRegistry<Self>) -> LuaResult<()> {
                fields.set_closure("a", |mut this: RefMut<Self>, val: i32| this.a = val)?;
                Ok(())
            }
        }

        let lua = Lua::with_open_libs();
        lua.global()
            .set_closure("add", |a: i64, b: i64| a + b)
            .unwrap();
        lua.global()
            .set(
                "strsub",
                lua.new_closure2(|_, s: &[u8], p: usize| &s[p..]).unwrap(),
            )
            .unwrap();
        lua.global().set_closure("getTest", Test::default).unwrap();

        lua.load_file("tests/bench.lua")
            .unwrap()
            .pcall_void(())
            .unwrap();
    }

    println!("------------- mlua -------------");
    {
        use mlua::prelude::*;

        impl LuaUserData for Test {
            fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) {
                fields.add_field_method_get("a", |_, this| Ok(this.a));
                fields.add_field_method_set("a", |_, this, a: i32| {
                    this.a = a;
                    Ok(())
                });
            }

            fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) {
                methods.add_method_mut("inc", |_, this, ()| {
                    this.a += 1;
                    Ok(())
                })
            }
        }

        let lua = unsafe { Lua::unsafe_new() };
        lua.load_from_std_lib(
            LuaStdLib::TABLE
                | LuaStdLib::MATH
                | LuaStdLib::IO
                | LuaStdLib::STRING
                | LuaStdLib::COROUTINE
                | LuaStdLib::PACKAGE
                | LuaStdLib::DEBUG
                | LuaStdLib::OS,
        )
        .expect("load stdlib");
        lua.globals()
            .set(
                "add",
                lua.create_function(|_, (a, b): (i64, i64)| Ok(a + b))
                    .unwrap(),
            )
            .unwrap();
        lua.globals()
            .set(
                "strsub",
                lua.create_function(|lua, (s, p): (LuaString, usize)| {
                    lua.create_string(&s.as_bytes()[p..])
                })
                .unwrap(),
            )
            .unwrap();
        lua.globals()
            .set(
                "getTest",
                lua.create_function(|_, ()| Ok(Test::default())).unwrap(),
            )
            .unwrap();

        lua.load(Path::new("tests/bench.lua"))
            .call::<_, ()>(())
            .unwrap();
    }
}