_ Git - rust-lightning/blob - lightning/src/sync/nostd_sync.rs

   1 pub use ::alloc::sync::Arc;
   2 use core::ops::{Deref, DerefMut};
   3 use core::time::Duration;
   4 use core::cell::{RefCell, Ref, RefMut};
   5 use super::{LockTestExt, LockHeldState};
   6
   7 pub type LockResult<Guard> = Result<Guard, ()>;
   8
   9 pub struct Condvar {}
  10
  11 impl Condvar {
  12         pub fn new() -> Condvar {
  13                 Condvar { }
  14         }
  15
  16         pub fn wait<'a, T>(&'a self, guard: MutexGuard<'a, T>) -> LockResult<MutexGuard<'a, T>> {
  17                 Ok(guard)
  18         }
  19
  20         #[allow(unused)]
  21         pub fn wait_timeout<'a, T>(&'a self, guard: MutexGuard<'a, T>, _dur: Duration) -> LockResult<(MutexGuard<'a, T>, ())> {
  22                 Ok((guard, ()))
  23         }
  24
  25         pub fn notify_all(&self) {}
  26 }
  27
  28 pub struct Mutex<T: ?Sized> {
  29         inner: RefCell<T>
  30 }
  31
  32 #[must_use = "if unused the Mutex will immediately unlock"]
  33 pub struct MutexGuard<'a, T: ?Sized + 'a> {
  34         lock: RefMut<'a, T>,
  35 }
  36
  37 impl<T: ?Sized> Deref for MutexGuard<'_, T> {
  38         type Target = T;
  39
  40         fn deref(&self) -> &T {
  41                 &self.lock.deref()
  42         }
  43 }
  44
  45 impl<T: ?Sized> DerefMut for MutexGuard<'_, T> {
  46         fn deref_mut(&mut self) -> &mut T {
  47                 self.lock.deref_mut()
  48         }
  49 }
  50
  51 impl<T> Mutex<T> {
  52         pub fn new(inner: T) -> Mutex<T> {
  53                 Mutex { inner: RefCell::new(inner) }
  54         }
  55
  56         pub fn lock<'a>(&'a self) -> LockResult<MutexGuard<'a, T>> {
  57                 Ok(MutexGuard { lock: self.inner.borrow_mut() })
  58         }
  59
  60         pub fn try_lock<'a>(&'a self) -> LockResult<MutexGuard<'a, T>> {
  61                 Ok(MutexGuard { lock: self.inner.borrow_mut() })
  62         }
  63 }
  64
  65 impl<'a, T: 'a> LockTestExt<'a> for Mutex<T> {
  66         #[inline]
  67         fn held_by_thread(&self) -> LockHeldState {
  68                 if self.lock().is_err() { return LockHeldState::HeldByThread; }
  69                 else { return LockHeldState::NotHeldByThread; }
  70         }
  71         type ExclLock = MutexGuard<'a, T>;
  72         #[inline]
  73         fn unsafe_well_ordered_double_lock_self(&'a self) -> MutexGuard<T> { self.lock().unwrap() }
  74 }
  75
  76 pub struct RwLock<T: ?Sized> {
  77         inner: RefCell<T>
  78 }
  79
  80 pub struct RwLockReadGuard<'a, T: ?Sized + 'a> {
  81         lock: Ref<'a, T>,
  82 }
  83
  84 pub struct RwLockWriteGuard<'a, T: ?Sized + 'a> {
  85         lock: RefMut<'a, T>,
  86 }
  87
  88 impl<T: ?Sized> Deref for RwLockReadGuard<'_, T> {
  89         type Target = T;
  90
  91         fn deref(&self) -> &T {
  92                 &self.lock.deref()
  93         }
  94 }
  95
  96 impl<T: ?Sized> Deref for RwLockWriteGuard<'_, T> {
  97         type Target = T;
  98
  99         fn deref(&self) -> &T {
 100                 &self.lock.deref()
 101         }
 102 }
 103
 104 impl<T: ?Sized> DerefMut for RwLockWriteGuard<'_, T> {
 105         fn deref_mut(&mut self) -> &mut T {
 106                 self.lock.deref_mut()
 107         }
 108 }
 109
 110 impl<T> RwLock<T> {
 111         pub fn new(inner: T) -> RwLock<T> {
 112                 RwLock { inner: RefCell::new(inner) }
 113         }
 114
 115         pub fn read<'a>(&'a self) -> LockResult<RwLockReadGuard<'a, T>> {
 116                 Ok(RwLockReadGuard { lock: self.inner.borrow() })
 117         }
 118
 119         pub fn write<'a>(&'a self) -> LockResult<RwLockWriteGuard<'a, T>> {
 120                 Ok(RwLockWriteGuard { lock: self.inner.borrow_mut() })
 121         }
 122
 123         pub fn try_write<'a>(&'a self) -> LockResult<RwLockWriteGuard<'a, T>> {
 124                 match self.inner.try_borrow_mut() {
 125                         Ok(lock) => Ok(RwLockWriteGuard { lock }),
 126                         Err(_) => Err(())
 127                 }
 128         }
 129 }
 130
 131 impl<'a, T: 'a> LockTestExt<'a> for RwLock<T> {
 132         #[inline]
 133         fn held_by_thread(&self) -> LockHeldState {
 134                 if self.write().is_err() { return LockHeldState::HeldByThread; }
 135                 else { return LockHeldState::NotHeldByThread; }
 136         }
 137         type ExclLock = RwLockWriteGuard<'a, T>;
 138         #[inline]
 139         fn unsafe_well_ordered_double_lock_self(&'a self) -> RwLockWriteGuard<T> { self.write().unwrap() }
 140 }
 141
 142 pub type FairRwLock<T> = RwLock<T>;