f Make poller error type generic

Author: tnull

lightning/src/onion_message/messenger.rs

@@ -1356,7 +1356,7 @@ where
 			futures.push(handler(ev));
 		}
 		// Let the `OnionMessageIntercepted` events finish before moving on to peer_connecteds
-		crate::util::async_poll::MultiEventFuturePoller::new(futures).await;
+		crate::util::async_poll::MultiResultFuturePoller::new(futures).await;
 
 		if peer_connecteds.len() <= 1 {
 			for event in peer_connecteds { handler(event).await; }
@@ -1365,7 +1365,7 @@ where
 			for event in peer_connecteds {
 				futures.push(handler(event));
 			}
-			crate::util::async_poll::MultiEventFuturePoller::new(futures).await;
+			crate::util::async_poll::MultiResultFuturePoller::new(futures).await;
 		}
 	}
 }

lightning/src/util/async_poll.rs

@@ -9,45 +9,49 @@
 
 //! Some utilities to make working with the standard library's [`Future`]s easier
 
-use crate::events::ReplayEvent;
 use crate::prelude::*;
 use core::future::Future;
 use core::marker::Unpin;
 use core::pin::Pin;
 use core::task::{Context, Poll};
 
-enum EventFuture<F: Future<Output = Result<(), ReplayEvent>>> {
+enum ResultFuture<F: Future<Output = Result<(), E>>, E: Copy + Unpin> {
 	Pending(F),
-	Ready(Result<(), ReplayEvent>),
+	Ready(Result<(), E>),
 }
 
-pub(crate) struct MultiEventFuturePoller<F: Future<Output = Result<(), ReplayEvent>> + Unpin> {
-	futures_state: Vec<EventFuture<F>>,
+pub(crate) struct MultiResultFuturePoller<
+	F: Future<Output = Result<(), E>> + Unpin,
+	E: Copy + Unpin,
+> {
+	futures_state: Vec<ResultFuture<F, E>>,
 }
 
-impl<F: Future<Output = Result<(), ReplayEvent>> + Unpin> MultiEventFuturePoller<F> {
+impl<F: Future<Output = Result<(), E>> + Unpin, E: Copy + Unpin> MultiResultFuturePoller<F, E> {
 	pub fn new(futures: Vec<F>) -> Self {
-		let futures_state = futures.into_iter().map(|f| EventFuture::Pending(f)).collect();
+		let futures_state = futures.into_iter().map(|f| ResultFuture::Pending(f)).collect();
 		Self { futures_state }
 	}
 }
 
-impl<F: Future<Output = Result<(), ReplayEvent>> + Unpin> Future for MultiEventFuturePoller<F> {
-	type Output = Vec<Result<(), ReplayEvent>>;
-	fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Vec<Result<(), ReplayEvent>>> {
+impl<F: Future<Output = Result<(), E>> + Unpin, E: Copy + Unpin> Future
+	for MultiResultFuturePoller<F, E>
+{
+	type Output = Vec<Result<(), E>>;
+	fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Vec<Result<(), E>>> {
 		let mut have_pending_futures = false;
 		let futures_state = &mut self.get_mut().futures_state;
 		for state in futures_state.iter_mut() {
 			match state {
-				EventFuture::Pending(ref mut fut) => match Pin::new(fut).poll(cx) {
+				ResultFuture::Pending(ref mut fut) => match Pin::new(fut).poll(cx) {
 					Poll::Ready(res) => {
-						*state = EventFuture::Ready(res);
+						*state = ResultFuture::Ready(res);
 					},
 					Poll::Pending => {
 						have_pending_futures = true;
 					},
 				},
-				EventFuture::Ready(_) => continue,
+				ResultFuture::Ready(_) => continue,
 			}
 		}
 
@@ -57,8 +61,8 @@ impl<F: Future<Output = Result<(), ReplayEvent>> + Unpin> Future for MultiEventF
 			let results = futures_state
 				.iter()
 				.filter_map(|e| match e {
-					EventFuture::Ready(res) => Some(res),
-					EventFuture::Pending(_) => {
+					ResultFuture::Ready(res) => Some(res),
+					ResultFuture::Pending(_) => {
 						debug_assert!(
 							false,
 							"All futures are expected to be ready if none are pending"