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
#![no_std]
use core::cell::UnsafeCell;
use core::fmt;
use core::marker::PhantomData;
use core::ops::Deref;
use core::ops::DerefMut;
use core::sync::atomic::AtomicBool;
use core::sync::atomic::Ordering;
pub struct SimpleLock<T: ?Sized> {
locked: AtomicBool,
value: UnsafeCell<T>,
}
unsafe impl<T: ?Sized + Send> Send for SimpleLock<T> {}
unsafe impl<T: ?Sized + Send> Sync for SimpleLock<T> {}
impl<T> SimpleLock<T> {
pub fn new(value: T) -> SimpleLock<T> {
SimpleLock {
locked: AtomicBool::new(false),
value: UnsafeCell::new(value),
}
}
}
impl<T: ?Sized + Default> Default for SimpleLock<T> {
fn default() -> SimpleLock<T> {
SimpleLock::new(T::default())
}
}
impl<T: ?Sized> SimpleLock<T> {
pub fn try_lock(&self) -> Option<SimpleLockGuard<T>> {
if self.locked.swap(true, Ordering::Acquire) {
None
} else {
Some(SimpleLockGuard {
parent: self,
_marker: PhantomData,
})
}
}
pub fn is_locked(&self) -> bool {
self.locked.load(Ordering::Relaxed)
}
}
impl<T> From<T> for SimpleLock<T> {
fn from(t: T) -> Self {
SimpleLock::new(t)
}
}
impl<T: ?Sized + fmt::Debug> fmt::Debug for SimpleLock<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self.try_lock() {
Some(guard) => f.debug_tuple("SimpleLock").field(&&*guard).finish(),
None => f.write_str("SimpleLock(<locked>)"),
}
}
}
pub struct SimpleLockGuard<'a, T: 'a + ?Sized> {
parent: &'a SimpleLock<T>,
_marker: PhantomData<*mut ()>,
}
unsafe impl<T: ?Sized + Sync> Sync for SimpleLockGuard<'_, T> {}
impl<T: ?Sized> Drop for SimpleLockGuard<'_, T> {
fn drop(&mut self) {
self.parent.locked.store(false, Ordering::Release);
}
}
impl<T: ?Sized> Deref for SimpleLockGuard<'_, T> {
type Target = T;
fn deref(&self) -> &Self::Target {
unsafe { &*self.parent.value.get() }
}
}
impl<T: ?Sized> DerefMut for SimpleLockGuard<'_, T> {
fn deref_mut(&mut self) -> &mut Self::Target {
unsafe { &mut *self.parent.value.get() }
}
}
impl<T: ?Sized + fmt::Debug> fmt::Debug for SimpleLockGuard<'_, T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::Debug::fmt(&**self, f)
}
}
impl<T: ?Sized + fmt::Display> fmt::Display for SimpleLockGuard<'_, T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
(**self).fmt(f)
}
}