gmodx 0.25.0

A swiss army knife for creating binary modules for Garry's Mod in Rust
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

use crate::lua::{self, Result, Value, ffi, private::Sealed};

pub trait ToLua: Sized {
    /// Pushes the value onto the Lua stack.
    fn push_to_stack(self, l: &lua::State);

    fn to_value(self, l: &lua::State) -> Value {
        self.push_to_stack(l); // push the value to the stack
        Value::pop_from_stack(l)
    }

    /// Number of stack values this pushes.
    fn stack_count() -> i32 {
        1
    }
}

pub trait FromLua: Sized {
    /// Creates the value from the Lua stack at the given index.
    fn try_from_stack(l: &lua::State, index: i32) -> Result<Self>;

    // the lua state is only used to ensure we are on main thread
    fn try_from_value(value: Value, _: &lua::State) -> Result<Self> {
        Self::try_from_stack(&value.ref_state(), value.index())
    }
}

pub trait ToLuaMulti: Sized {
    fn push_to_stack_multi(self, l: &lua::State);

    /// Returns the number of values pushed. Override when the count is known cheaply.
    fn push_to_stack_multi_count(self, l: &lua::State) -> i32 {
        let base = ffi::lua_gettop(l.0);
        self.push_to_stack_multi(l);
        ffi::lua_gettop(l.0) - base
    }
}

impl<T: ToLua> ToLuaMulti for T {
    fn push_to_stack_multi(self, l: &lua::State) {
        self.push_to_stack(l);
    }

    fn push_to_stack_multi_count(self, l: &lua::State) -> i32 {
        self.push_to_stack(l);
        T::stack_count()
    }
}

pub trait FromLuaMulti: Sized {
    fn try_from_stack_multi(l: &lua::State, start_index: i32, count: i32) -> Result<(Self, i32)>;
}

impl<T: FromLua> FromLuaMulti for T {
    fn try_from_stack_multi(l: &lua::State, start_index: i32, _: i32) -> Result<(Self, i32)> {
        T::try_from_stack(l, start_index).map(|v| (v, 1))
    }
}

pub trait ObjectLike: Sealed {
    /// Gets the value associated to `key` from the object, assuming it has `__index` metamethod.
    fn get<V: FromLua>(&self, l: &lua::State, key: impl ToLua) -> Result<V>;

    /// Sets the value associated to `key` in the object, assuming it has `__newindex` metamethod.
    fn set(&self, l: &lua::State, key: impl ToLua, value: impl ToLua) -> Result<()>;

    /// Gets the function associated to key `name` from the object and calls it,
    /// passing `args` as function arguments.
    ///
    /// This might invoke the `__index` metamethod.
    fn call<R: FromLuaMulti>(
        &self,
        l: &lua::State,
        name: &str,
        args: impl ToLuaMulti,
    ) -> lua::Result<R>;

    /// Gets the function associated to key `name` from the object and calls it,
    /// passing the object itself along with `args` as function arguments.
    fn call_method<R: FromLuaMulti>(
        &self,
        l: &lua::State,
        name: &str,
        args: impl ToLuaMulti,
    ) -> lua::Result<R>;
}