_ 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<T> LockTestExt 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 }
  72
  73 pub struct RwLock<T: ?Sized> {
  74         inner: RefCell<T>
  75 }
  76
  77 pub struct RwLockReadGuard<'a, T: ?Sized + 'a> {
  78         lock: Ref<'a, T>,
  79 }
  80
  81 pub struct RwLockWriteGuard<'a, T: ?Sized + 'a> {
  82         lock: RefMut<'a, T>,
  83 }
  84
  85 impl<T: ?Sized> Deref for RwLockReadGuard<'_, T> {
  86         type Target = T;
  87
  88         fn deref(&self) -> &T {
  89                 &self.lock.deref()
  90         }
  91 }
  92
  93 impl<T: ?Sized> Deref for RwLockWriteGuard<'_, T> {
  94         type Target = T;
  95
  96         fn deref(&self) -> &T {
  97                 &self.lock.deref()
  98         }
  99 }
 100
 101 impl<T: ?Sized> DerefMut for RwLockWriteGuard<'_, T> {
 102         fn deref_mut(&mut self) -> &mut T {
 103                 self.lock.deref_mut()
 104         }
 105 }
 106
 107 impl<T> RwLock<T> {
 108         pub fn new(inner: T) -> RwLock<T> {
 109                 RwLock { inner: RefCell::new(inner) }
 110         }
 111
 112         pub fn read<'a>(&'a self) -> LockResult<RwLockReadGuard<'a, T>> {
 113                 Ok(RwLockReadGuard { lock: self.inner.borrow() })
 114         }
 115
 116         pub fn write<'a>(&'a self) -> LockResult<RwLockWriteGuard<'a, T>> {
 117                 Ok(RwLockWriteGuard { lock: self.inner.borrow_mut() })
 118         }
 119
 120         pub fn try_write<'a>(&'a self) -> LockResult<RwLockWriteGuard<'a, T>> {
 121                 match self.inner.try_borrow_mut() {
 122                         Ok(lock) => Ok(RwLockWriteGuard { lock }),
 123                         Err(_) => Err(())
 124                 }
 125         }
 126 }
 127
 128 impl<T> LockTestExt for RwLock<T> {
 129         #[inline]
 130         fn held_by_thread(&self) -> LockHeldState {
 131                 if self.write().is_err() { return LockHeldState::HeldByThread; }
 132                 else { return LockHeldState::NotHeldByThread; }
 133         }
 134 }
 135
 136 pub type FairRwLock<T> = RwLock<T>;