hlua 0.4.3

Zero-cost high-level wrapper for Lua
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

#[macro_use]
extern crate hlua;

fn main() {
    let mut lua = hlua::Lua::new();
    lua.openlibs();

    // we create a fill an array named `Sound` which will be used as a class-like interface
    {
        let mut sound_namespace = lua.empty_array("Sound");

        // creating the `Sound.new` function
        sound_namespace.set("new", hlua::function0(|| Sound::new()));
    }

    lua.execute::<()>(
        r#"
        s = Sound.new();
        s:play();

        print("hello world from within lua!");
        print("is the sound playing:", s:is_playing());

        s:stop();
        print("is the sound playing:", s:is_playing());

    "#,
    )
    .unwrap();
}

// this `Sound` struct is the object that we will use to demonstrate hlua
struct Sound {
    playing: bool,
}

// this macro implements the required trait so that we can *push* the object to lua
// (ie. move it inside lua)
implement_lua_push!(Sound, |mut metatable| {
    // we create a `__index` entry in the metatable
    // when the lua code calls `sound:play()`, it will look for `play` in there
    let mut index = metatable.empty_array("__index");

    index.set("play", hlua::function1(|snd: &mut Sound| snd.play()));

    index.set("stop", hlua::function1(|snd: &mut Sound| snd.stop()));

    index.set(
        "is_playing",
        hlua::function1(|snd: &Sound| snd.is_playing()),
    );
});

// this macro implements the require traits so that we can *read* the object back
implement_lua_read!(Sound);

impl Sound {
    pub fn new() -> Sound {
        Sound { playing: false }
    }

    pub fn play(&mut self) {
        println!("playing");
        self.playing = true;
    }

    pub fn stop(&mut self) {
        println!("stopping");
        self.playing = false;
    }

    pub fn is_playing(&self) -> bool {
        self.playing
    }
}

// this destructor is here to show you that objects are properly getting destroyed
impl Drop for Sound {
    fn drop(&mut self) {
        println!("`Sound` object destroyed");
    }
}