Implement dummy RwLock

Author: devrandom

lightning/src/sync.rs

@@ -1,8 +1,7 @@
-pub use ::std::sync::{RwLock, RwLockReadGuard};
 pub use ::alloc::sync::Arc;
 use core::ops::{Deref, DerefMut};
 use core::time::Duration;
-use core::cell::{RefCell, RefMut};
+use core::cell::{RefCell, Ref, RefMut};
 
 pub type LockResult<Guard> = Result<Guard, ()>;
 
@@ -64,4 +63,59 @@ impl Condvar {
 	}
 
 	pub fn notify_all(&self) {}
-}
+}
+
+/// This no_std version of RwLock actually only allows one lock at a time, because
+/// we are not expecting reentrancy in our straight-line code.
+pub struct RwLock<T: ?Sized> {
+	inner: RefCell<T>
+}
+
+pub struct RwLockReadGuard<'a, T: ?Sized + 'a> {
+	lock: Ref<'a, T>,
+}
+
+pub struct RwLockWriteGuard<'a, T: ?Sized + 'a> {
+	lock: RefMut<'a, T>,
+}
+
+impl<T: ?Sized> Deref for RwLockReadGuard<'_, T> {
+	type Target = T;
+
+	fn deref(&self) -> &T {
+		&self.lock.deref()
+	}
+}
+
+impl<T: ?Sized> Deref for RwLockWriteGuard<'_, T> {
+	type Target = T;
+
+	fn deref(&self) -> &T {
+		&self.lock.deref()
+	}
+}
+
+impl<T: ?Sized> DerefMut for RwLockWriteGuard<'_, T> {
+	fn deref_mut(&mut self) -> &mut T {
+		self.lock.deref_mut()
+	}
+}
+
+impl<T> RwLock<T> {
+	pub fn new(inner: T) -> RwLock<T> {
+		RwLock { inner: RefCell::new(inner) }
+	}
+
+	pub fn read(&self) -> LockResult<RwLockReadGuard<'_, T>> {
+		Ok(RwLockReadGuard { lock: self.inner.borrow() })
+	}
+
+	pub fn write(&self) -> LockResult<RwLockWriteGuard<'_, T>> {
+		Ok(RwLockWriteGuard { lock: self.inner.borrow_mut() })
+	}
+
+	pub fn try_write(&self) -> LockResult<RwLockWriteGuard<'_, T>> {
+		// There is no try, grasshopper - only used for tests and expected to fail
+		Err(())
+	}
+}