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

use std::cell::UnsafeCell;

use xutex::{ReentrantMutex, ReentrantMutexGuard};

use crate::lua::{self};
use crate::open_close::get_main_lua_state;

// pub(crate) mod reentrant_mutex;

struct GuardHolder(UnsafeCell<Option<ReentrantMutexGuard<'static, ()>>>);
unsafe impl Sync for GuardHolder {}

static LUA_LOCK: ReentrantMutex<()> = ReentrantMutex::new(());
static MAIN_GUARD: GuardHolder = GuardHolder(UnsafeCell::new(None));
pub struct StateGuard {
    _g: ReentrantMutexGuard<'static, ()>,
    state: lua::State,
}

impl std::ops::Deref for StateGuard {
    type Target = lua::State;
    fn deref(&self) -> &Self::Target {
        &self.state
    }
}

#[inline(always)]
fn main_lock() {
    unsafe {
        *MAIN_GUARD.0.get() = Some(LUA_LOCK.lock());
    }
}

#[inline(always)]
fn main_unlock() {
    unsafe {
        *MAIN_GUARD.0.get() = None;
    }
}

#[inline(always)]
fn yield_lock(_: &lua::State) {
    if let Some(guard) = unsafe { (*MAIN_GUARD.0.get()).as_mut() } {
        ReentrantMutexGuard::bump(guard);
    }
}

#[inline(always)]
fn get_state_guard(guard: ReentrantMutexGuard<'static, ()>) -> Option<StateGuard> {
    if crate::is_closed() {
        return None;
    }
    Some(StateGuard {
        _g: guard,
        state: get_main_lua_state(),
    })
}

pub fn lock() -> Option<StateGuard> {
    get_state_guard(LUA_LOCK.lock())
}

pub fn try_lock() -> Option<StateGuard> {
    LUA_LOCK.try_lock().and_then(get_state_guard)
}

pub fn with_lock<F, R>(f: F) -> Option<R>
where
    F: FnOnce(&lua::State) -> R,
{
    let guard = lock()?;
    Some(f(&guard))
}

pub async fn lock_async() -> Option<StateGuard> {
    get_state_guard(LUA_LOCK.lock_async().await)
}

pub async fn with_lock_async<F, R>(f: F) -> Option<R>
where
    F: FnOnce(&lua::State) -> R,
{
    let guard = lock_async().await?;
    Some(f(&guard))
}

inventory::submit! {
    crate::open_close::new(
        0,
        "lock",
        |_| {
            main_lock();
            crate::timer::create("gmodx_state_lock_timer", 0, 0, yield_lock);
        },
        |_| {
            // Lock to ensure no other threads are using the state
            main_lock();
            main_unlock();
        },
    )
}