Add a `MutexGuard` wrapper for the bindings-only `LockableScore`

In the bindings, we don't directly export any `std` types. Instead,
we provide trivial wrappers around them which expose only a
bindings-compatible API (and which is code in-crate, where the
bindings generator can see it).

We never quite finished this for `MultiThreadedLockableScore` - due
to some limitations in the bindings generator and the way the
scores are used in `lightning-invoice`, the scoring API ended up
being further concretized in patches for the bindings. Luckily the
scoring interface has been rewritten somewhat, and it so happens
that we can now generate bindings with the upstream code.

The final piece of the puzzle is done here, where we add a struct
which wraps `MutexGuard` so that we can expose the lock for
`MultiThreadedLockableScore`.

diff --git a/lightning/src/routing/scoring.rs b/lightning/src/routing/scoring.rs
index a3d970715872433d40572d98301b0309419876ab..5a2c45260c5c35058cace3ad2eb6a8c1c9a13d4c 100644 (file)
--- a/lightning/src/routing/scoring.rs
+++ b/lightning/src/routing/scoring.rs
@@ -188,12 +188,39 @@ pub struct MultiThreadedLockableScore<S: Score> {
        score: Mutex<S>,
 }
 #[cfg(c_bindings)]
-/// (C-not exported)
+/// A locked `MultiThreadedLockableScore`.
+pub struct MultiThreadedLockableScoreLock<'a, S: Score>(MutexGuard<'a, S>);
+#[cfg(c_bindings)]
+impl<'a, T: Score + 'a> Score for MultiThreadedLockableScoreLock<'a, T> {
+       fn channel_penalty_msat(&self, scid: u64, source: &NodeId, target: &NodeId, usage: ChannelUsage) -> u64 {
+               self.0.channel_penalty_msat(scid, source, target, usage)
+       }
+       fn payment_path_failed(&mut self, path: &[&RouteHop], short_channel_id: u64) {
+               self.0.payment_path_failed(path, short_channel_id)
+       }
+       fn payment_path_successful(&mut self, path: &[&RouteHop]) {
+               self.0.payment_path_successful(path)
+       }
+       fn probe_failed(&mut self, path: &[&RouteHop], short_channel_id: u64) {
+               self.0.probe_failed(path, short_channel_id)
+       }
+       fn probe_successful(&mut self, path: &[&RouteHop]) {
+               self.0.probe_successful(path)
+       }
+}
+#[cfg(c_bindings)]
+impl<'a, T: Score + 'a> Writeable for MultiThreadedLockableScoreLock<'a, T> {
+       fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
+               self.0.write(writer)
+       }
+}
+
+#[cfg(c_bindings)]
 impl<'a, T: Score + 'a> LockableScore<'a> for MultiThreadedLockableScore<T> {
-       type Locked = MutexGuard<'a, T>;
+       type Locked = MultiThreadedLockableScoreLock<'a, T>;
 
-       fn lock(&'a self) -> MutexGuard<'a, T> {
-               Mutex::lock(&self.score).unwrap()
+       fn lock(&'a self) -> MultiThreadedLockableScoreLock<'a, T> {
+               MultiThreadedLockableScoreLock(Mutex::lock(&self.score).unwrap())
        }
 }