Split MultiThreadedScoreLock into MultiThreadedScoreLockWrite and MultiThreadedScoreLockRead

After splitting LockableScore, we split MultiThreadedScoreLock following
the same way, splitting a single score into two srtucts, one for read and
other for write.
MultiThreadedScoreLock is used in c_bindings.

Author: jbesraa

lightning/src/routing/scoring.rs

@@ -223,6 +223,7 @@ impl<'a, T: 'a + ScoreUpdate + ScoreLookUp> LockableScore<'a> for RefCell<T> {
 	}
 }
 
+#[cfg(not(c_bindings))]
 impl<'a, SP:Sized,  T: 'a + ScoreUpdate + ScoreLookUp<ScoreParams = SP>> LockableScore<'a> for RwLock<T> {
 	type ScoreUpdate = T;
 	type ScoreLookUp = T;
@@ -249,15 +250,15 @@ pub struct MultiThreadedLockableScore<T: ScoreLookUp + ScoreUpdate> {
 impl<'a, SP:Sized, T: 'a + ScoreLookUp<ScoreParams = SP> + ScoreUpdate> LockableScore<'a> for MultiThreadedLockableScore<T> {
 	type ScoreUpdate = T;
 	type ScoreLookUp = T;
-	type WriteLocked = RwLockWriteGuard<'a, Self::ScoreUpdate>;
-	type ReadLocked = RwLockReadGuard<'a, Self::ScoreLookUp>;
+	type WriteLocked = MultiThreadedScoreLockWrite<'a, Self::ScoreUpdate>;
+	type ReadLocked = MultiThreadedScoreLockRead<'a, Self::ScoreLookUp>;
 
 	fn read_lock(&'a self) -> Self::ReadLocked {
-		RwLock::read(&self.score).unwrap()
+		MultiThreadedScoreLockRead(self.score.read().unwrap())
 	}
 
 	fn write_lock(&'a self) -> Self::WriteLocked {
-		RwLock::write(&self.score).unwrap()
+		MultiThreadedScoreLockWrite(self.score.write().unwrap())
 	}
 }
 
@@ -281,31 +282,43 @@ impl<T: ScoreLookUp + ScoreUpdate> MultiThreadedLockableScore<T> {
 
 #[cfg(c_bindings)]
 /// A locked `MultiThreadedLockableScore`.
-pub struct MultiThreadedScoreLock<'a, T: ScoreLookUp + ScoreUpdate>(MutexGuard<'a, T>);
+pub struct MultiThreadedScoreLockRead<'a, T: ScoreLookUp>(RwLockReadGuard<'a, T>);
+
+#[cfg(c_bindings)]
+/// A locked `MultiThreadedLockableScore`.
+pub struct MultiThreadedScoreLockWrite<'a, T: ScoreUpdate>(RwLockWriteGuard<'a, T>);
 
 #[cfg(c_bindings)]
-impl<'a, T: 'a + ScoreUpdate + ScoreLookUp> Writeable for MultiThreadedScoreLock<'a, T> {
+impl<'a, T: 'a + ScoreUpdate> Writeable for MultiThreadedScoreLockWrite<'a, T> {
 	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
 		self.0.write(writer)
 	}
 }
 
 #[cfg(c_bindings)]
-impl<'a, T: 'a + ScoreUpdate + ScoreLookUp> DerefMut for MultiThreadedScoreLock<'a, T> {
-	fn deref_mut(&mut self) -> &mut Self::Target {
-		self.0.deref_mut()
+impl<'a, T: 'a + ScoreLookUp> Deref for MultiThreadedScoreLockRead<'a, T> {
+	type Target = T;
+
+	fn deref(&self) -> &Self::Target {
+		self.0.deref()
 	}
 }
 
 #[cfg(c_bindings)]
-impl<'a, T: 'a + ScoreUpdate + ScoreLookUp> Deref for MultiThreadedScoreLock<'a, T> {
+impl<'a, T: 'a + ScoreUpdate> Deref for MultiThreadedScoreLockWrite<'a, T> {
 	type Target = T;
 
 	fn deref(&self) -> &Self::Target {
 		self.0.deref()
 	}
 }
 
+#[cfg(c_bindings)]
+impl<'a, T: 'a + ScoreUpdate> DerefMut for MultiThreadedScoreLockWrite<'a, T> {
+	fn deref_mut(&mut self) -> &mut Self::Target {
+		self.0.deref_mut()
+	}
+}
 
 
 /// Proposed use of a channel passed as a parameter to [`ScoreLookUp::channel_penalty_msat`].