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
134
135
136
137
138
139
140
141
142
143
144
145
146
147

#[cfg(feature = "owning_ref")]
use owning_ref::StableAddress;
#[cfg(feature = "check")]
use std::sync::atomic::{AtomicBool, Ordering};
use std::{
    cell::UnsafeCell,
    ops::{Deref, DerefMut},
    panic::{RefUnwindSafe, UnwindSafe},
};

/// A mutual exclusive lock
#[derive(Debug)]
pub struct Mutex<T: ?Sized> {
    #[cfg(feature = "check")]
    state: AtomicBool,
    value: UnsafeCell<T>,
}

impl<T> RefUnwindSafe for Mutex<T> where T: ?Sized {}
impl<T> UnwindSafe for Mutex<T> where T: ?Sized {}
unsafe impl<T> Send for Mutex<T> where T: ?Sized + Send {}
unsafe impl<T> Sync for Mutex<T> where T: ?Sized + Send {}

impl<T> From<T> for Mutex<T> {
    fn from(val: T) -> Self {
        Self::new(val)
    }
}

impl<T> Default for Mutex<T>
where
    T: ?Sized + Default,
{
    fn default() -> Self {
        Self::new(T::default())
    }
}

impl<T> Mutex<T> {
    /// Create a new `Mutex`.
    pub fn new(val: T) -> Self {
        Self {
            #[cfg(feature = "check")]
            state: AtomicBool::new(false),
            value: UnsafeCell::new(val),
        }
    }

    /// Consume the `Mutex`, returning the inner value.
    pub fn into_inner(self) -> T {
        self.value.into_inner()
    }
}

impl<T> Mutex<T>
where
    T: ?Sized,
{
    /// Get a mutable reference of the inner value T. This is safe because we
    /// have the mutable reference of the lock.
    pub fn get_mut(&mut self) -> &mut T {
        self.value.get_mut()
    }

    /// Try lock the `Mutex`, returns the mutex guard. Returns None if the
    /// `Mutex` is write locked.
    pub fn try_lock<'a>(&'a self) -> Option<MutexGuard<'a, T>> {
        self.lock_exclusive().then(|| MutexGuard { lock: self })
    }

    /// Lock the `Mutex`, returns the mutex guard.
    ///
    /// # Panics
    ///
    /// If the `Mutex` is already locked, this will panic if the `check` feature
    /// is turned on.
    pub fn lock<'a>(&'a self) -> MutexGuard<'a, T> {
        if !self.lock_exclusive() {
            #[cfg(feature = "check")]
            panic!("The lock is already write locked")
        }

        MutexGuard { lock: self }
    }

    fn lock_exclusive(&self) -> bool {
        #[cfg(feature = "check")]
        {
            self.state
                .compare_exchange(false, true, Ordering::Acquire, Ordering::Relaxed)
                .is_ok()
        }

        #[cfg(not(feature = "check"))]
        true
    }

    fn unlock_exclusive(&self) -> bool {
        #[cfg(feature = "check")]
        {
            self.state
                .compare_exchange(true, false, Ordering::Acquire, Ordering::Relaxed)
                .is_ok()
        }

        #[cfg(not(feature = "check"))]
        true
    }
}

pub struct MutexGuard<'a, T>
where
    T: ?Sized,
{
    lock: &'a Mutex<T>,
}

impl<'a, T> Deref for MutexGuard<'a, T>
where
    T: ?Sized,
{
    type Target = T;
    fn deref(&self) -> &T {
        unsafe { &*self.lock.value.get() }
    }
}

impl<'a, T> DerefMut for MutexGuard<'a, T>
where
    T: ?Sized,
{
    fn deref_mut(&mut self) -> &mut T {
        unsafe { &mut *self.lock.value.get() }
    }
}

impl<'a, T> Drop for MutexGuard<'a, T>
where
    T: ?Sized,
{
    fn drop(&mut self) {
        self.lock.unlock_exclusive();
    }
}

#[cfg(feature = "owning_ref")]
unsafe impl<'a, T: 'a> StableAddress for MutexGuard<'a, T> where T: ?Sized {}