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
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use std::{
    cell::{Ref, RefCell, RefMut},
    ffi::c_void,
};

use crate::lua::{self, AnyUserData, Error, FromLua, Result, ToLua, UserData, Value};

/// The 'static bound is needed to ensure the userdata lives long enough
#[derive(Debug)]
pub struct UserDataRef<T: UserData + 'static> {
    /// Pointer to the userdata in Lua
    pub(crate) ptr: *const c_void,
    pub(crate) any: AnyUserData,
    pub(crate) _marker: std::marker::PhantomData<T>,
}

impl<T: UserData> Clone for UserDataRef<T> {
    fn clone(&self) -> Self {
        Self {
            ptr: self.ptr,
            any: self.any.clone(),
            _marker: std::marker::PhantomData,
        }
    }
}

impl<T: UserData> UserDataRef<T> {
    #[inline]
    const fn downcast(&self) -> &RefCell<T> {
        // SAFETY: The pointer is valid as long as the inner value is alive.
        // SAFETY: We type check before initializing UserDataRef.
        unsafe { &*(self.ptr.cast::<RefCell<T>>()) }
    }

    #[must_use]
    #[inline]
    pub fn borrow(&self) -> Ref<'_, T> {
        self.downcast().borrow()
    }

    #[must_use]
    #[inline]
    pub fn borrow_mut(&self) -> RefMut<'_, T> {
        self.downcast().borrow_mut()
    }

    #[inline]
    pub fn try_borrow(&self) -> Result<Ref<'_, T>> {
        self.downcast()
            .try_borrow()
            .map_err(|err| Error::Message(format!("cannot borrow '{}': {}", T::name(), err)))
    }

    #[inline]
    pub fn try_borrow_mut(&self) -> Result<RefMut<'_, T>> {
        self.downcast().try_borrow_mut().map_err(|err| {
            Error::Message(format!("cannot borrow '{}' mutably: {}", T::name(), err))
        })
    }

    #[must_use]
    #[inline]
    pub const fn as_any(&self) -> &AnyUserData {
        &self.any
    }

    #[must_use]
    #[inline]
    pub fn into_any(self) -> AnyUserData {
        self.any
    }
}

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

    fn to_value(self, l: &lua::State) -> Value {
        self.any.to_value(l)
    }
}

impl<T: UserData> ToLua for &UserDataRef<T> {
    fn push_to_stack(self, l: &lua::State) {
        #[allow(clippy::needless_borrow)]
        (&self.any).push_to_stack(l);
    }

    fn to_value(self, _: &lua::State) -> Value {
        self.any.0.clone()
    }
}

impl<T: UserData> FromLua for UserDataRef<T> {
    fn try_from_stack(l: &lua::State, index: i32) -> Result<Self> {
        let name = T::name();
        let any = AnyUserData::from_stack_with_type(l, index, name)?;
        any.cast_to::<T>(l).ok_or_else(|| l.type_error(index, name))
    }
}

impl<T: UserData> From<UserDataRef<T>> for AnyUserData {
    fn from(udref: UserDataRef<T>) -> Self {
        udref.any
    }
}

impl AnyUserData {
    #[must_use]
    #[inline]
    pub fn cast_to<T: UserData>(self, l: &lua::State) -> Option<UserDataRef<T>> {
        if !self.is::<RefCell<T>>(l) {
            return None;
        }
        Some(UserDataRef {
            ptr: self.ptr(),
            any: self,
            _marker: std::marker::PhantomData,
        })
    }
}

impl lua::State {
    pub fn create_userdata<T: UserData>(&self, ud: T) -> UserDataRef<T> {
        let (ptr, any) = self.create_userdata_impl::<_, T>(RefCell::new(ud));
        UserDataRef {
            ptr,
            any,
            _marker: std::marker::PhantomData,
        }
    }
}