Converting built up vectors to iterators in the

`lightning-invoice/src/utils.rs` file

- functions converted:
    - `select_phantom_hints`
    - `sort_and_filter_channels`

Author: upjohnc

lightning-invoice/src/utils.rs

@@ -241,7 +241,7 @@ where
 	for PhantomRouteHints { channels, phantom_scid, real_node_pubkey } in phantom_route_hints {
 		log_trace!(logger, "Generating phantom route hints for node {}",
 			log_pubkey!(real_node_pubkey));
-		let mut route_hints = sort_and_filter_channels(channels, amt_msat, &logger);
+		let mut route_hints: Vec<RouteHint> = sort_and_filter_channels(channels, amt_msat, &logger).collect();
 
 		// If we have any public channel, the route hints from `sort_and_filter_channels` will be
 		// empty. In that case we create a RouteHint on which we will push a single hop with the
@@ -270,36 +270,36 @@ where
 	// the hints across our real nodes we add one hint from each in turn until no node has any hints
 	// left (if one node has more hints than any other, these will accumulate at the end of the
 	// vector).
-    rotate_nested_vectors(phantom_hints)
+	rotate_nested_vectors(phantom_hints)
 
 }
 
 // Draw items iteratively from multiple nested vectors.  The items are retrieved by index and
 // rotates through the vectors - first the zero index then the first index then second index, etc.
 fn rotate_nested_vectors<T: Clone>(vecs: Vec<Vec<T>>) -> impl Iterator<Item = T> {
-    let max_vector_length: usize = vecs.iter().map(|x| x.len()).max().unwrap();
-    let mut hint_index = 0;
-    let mut vector_index = 0;
-    let number_inner_vectors: usize = vecs.len();
-
-    core::iter::from_fn(move || loop {
-        if hint_index == max_vector_length {
-            return None;
-        };
-        let hint_value = if vecs[vector_index].len() != 0 && vecs[vector_index].len() > hint_index {
-            Some(vecs[vector_index][hint_index].clone())
-        } else {
-            None // no value retrieved - continue looping
-        };
-        vector_index += 1;
-        if hint_index < max_vector_length && vector_index == number_inner_vectors {
-            vector_index = 0;
-            hint_index += 1;
-        };
-        if !hint_value.is_none() {
-            return hint_value;
-        };
-    })
+	let max_vector_length: usize = vecs.iter().map(|x| x.len()).max().unwrap();
+	let mut hint_index = 0;
+	let mut vector_index = 0;
+	let number_inner_vectors: usize = vecs.len();
+
+	core::iter::from_fn(move || loop {
+		if hint_index == max_vector_length {
+			return None;
+		};
+		let hint_value = if vecs[vector_index].len() != 0 && vecs[vector_index].len() > hint_index {
+			Some(vecs[vector_index][hint_index].clone())
+		} else {
+			None // no value retrieved - continue looping
+		};
+		vector_index += 1;
+		if hint_index < max_vector_length && vector_index == number_inner_vectors {
+			vector_index = 0;
+			hint_index += 1;
+		};
+		if !hint_value.is_none() {
+			return hint_value;
+		};
+	})
 }
 
 #[cfg(feature = "std")]
@@ -585,15 +585,34 @@ fn _create_invoice_from_channelmanager_and_duration_since_epoch_with_payment_has
 /// * Sorted by lowest inbound capacity if an online channel with the minimum amount requested exists,
 ///   otherwise sort by highest inbound capacity to give the payment the best chance of succeeding.
 fn sort_and_filter_channels<L: Deref>(
-	channels: Vec<ChannelDetails>, min_inbound_capacity_msat: Option<u64>, logger: &L
-) -> Vec<RouteHint> where L::Target: Logger {
+	channels: Vec<ChannelDetails>,
+	min_inbound_capacity_msat: Option<u64>,
+	logger: &L,
+) -> impl Iterator<Item = RouteHint>
+where
+	L::Target: Logger,
+{
 	let mut filtered_channels: HashMap<PublicKey, ChannelDetails> = HashMap::new();
 	let min_inbound_capacity = min_inbound_capacity_msat.unwrap_or(0);
 	let mut min_capacity_channel_exists = false;
 	let mut online_channel_exists = false;
 	let mut online_min_capacity_channel_exists = false;
 	let mut has_pub_unconf_chan = false;
 
+	let route_hint_from_channel = |channel: ChannelDetails| {
+		let forwarding_info = channel.counterparty.forwarding_info.as_ref().unwrap();
+		RouteHint(vec![RouteHintHop {
+			src_node_id: channel.counterparty.node_id,
+			short_channel_id: channel.get_inbound_payment_scid().unwrap(),
+			fees: RoutingFees {
+				base_msat: forwarding_info.fee_base_msat,
+				proportional_millionths: forwarding_info.fee_proportional_millionths,
+			},
+			cltv_expiry_delta: forwarding_info.cltv_expiry_delta,
+			htlc_minimum_msat: channel.inbound_htlc_minimum_msat,
+			htlc_maximum_msat: channel.inbound_htlc_maximum_msat,}])
+	};
+
 	log_trace!(logger, "Considering {} channels for invoice route hints", channels.len());
 	for channel in channels.into_iter().filter(|chan| chan.is_channel_ready) {
 		if channel.get_inbound_payment_scid().is_none() || channel.counterparty.forwarding_info.is_none() {
@@ -612,7 +631,7 @@ fn sort_and_filter_channels<L: Deref>(
 				// look at the public channels instead.
 				log_trace!(logger, "Not including channels in invoice route hints on account of public channel {}",
 					log_bytes!(channel.channel_id));
-				return vec![]
+				return vec![].into_iter().take(3).map(route_hint_from_channel);
 			}
 		}
 
@@ -672,19 +691,6 @@ fn sort_and_filter_channels<L: Deref>(
 		}
 	}
 
-	let route_hint_from_channel = |channel: ChannelDetails| {
-		let forwarding_info = channel.counterparty.forwarding_info.as_ref().unwrap();
-		RouteHint(vec![RouteHintHop {
-			src_node_id: channel.counterparty.node_id,
-			short_channel_id: channel.get_inbound_payment_scid().unwrap(),
-			fees: RoutingFees {
-				base_msat: forwarding_info.fee_base_msat,
-				proportional_millionths: forwarding_info.fee_proportional_millionths,
-			},
-			cltv_expiry_delta: forwarding_info.cltv_expiry_delta,
-			htlc_minimum_msat: channel.inbound_htlc_minimum_msat,
-			htlc_maximum_msat: channel.inbound_htlc_maximum_msat,}])
-	};
 	// If all channels are private, prefer to return route hints which have a higher capacity than
 	// the payment value and where we're currently connected to the channel counterparty.
 	// Even if we cannot satisfy both goals, always ensure we include *some* hints, preferring
@@ -734,7 +740,8 @@ fn sort_and_filter_channels<L: Deref>(
 			} else {
 				b.inbound_capacity_msat.cmp(&a.inbound_capacity_msat)
 			}});
-		eligible_channels.into_iter().take(3).map(route_hint_from_channel).collect::<Vec<RouteHint>>()
+
+		eligible_channels.into_iter().take(3).map(route_hint_from_channel)
 }
 
 /// prefer_current_channel chooses a channel to use for route hints between a currently selected and candidate
@@ -1898,110 +1905,110 @@ mod test {
 	}
 
 
-    #[test]
-    fn test_zip_nested_vectors() {
+	#[test]
+	fn test_zip_nested_vectors() {
 		// two nested vectors
-        let a = vec![vec!["a0", "b0", "c0"], vec!["a1", "b1"]];
-        let result = rotate_nested_vectors(a).collect::<Vec<_>>();
+		let a = vec![vec!["a0", "b0", "c0"], vec!["a1", "b1"]];
+		let result = rotate_nested_vectors(a).collect::<Vec<_>>();
 
-        let expected = vec!["a0", "a1", "b0", "b1", "c0"];
-        assert_eq!(expected, result);
+		let expected = vec!["a0", "a1", "b0", "b1", "c0"];
+		assert_eq!(expected, result);
 
-        // test single nested vector
-        let a = vec![vec!["a0", "b0", "c0"]];
-        let result = rotate_nested_vectors(a).collect::<Vec<_>>();
+		// test single nested vector
+		let a = vec![vec!["a0", "b0", "c0"]];
+		let result = rotate_nested_vectors(a).collect::<Vec<_>>();
 
-        let expected = vec!["a0", "b0", "c0"];
-        assert_eq!(expected, result);
+		let expected = vec!["a0", "b0", "c0"];
+		assert_eq!(expected, result);
 
-        // test second vector with only one element
-        let a = vec![vec!["a0", "b0", "c0"], vec!["a1"]];
-        let result = rotate_nested_vectors(a).collect::<Vec<_>>();
+		// test second vector with only one element
+		let a = vec![vec!["a0", "b0", "c0"], vec!["a1"]];
+		let result = rotate_nested_vectors(a).collect::<Vec<_>>();
 
-        let expected = vec!["a0", "a1", "b0", "c0"];
-        assert_eq!(expected, result);
+		let expected = vec!["a0", "a1", "b0", "c0"];
+		assert_eq!(expected, result);
 
-        // test three nestend vectors
-        let a = vec![vec!["a0"], vec!["a1", "b1", "c1"], vec!["a2"]];
-        let result = rotate_nested_vectors(a).collect::<Vec<_>>();
+		// test three nestend vectors
+		let a = vec![vec!["a0"], vec!["a1", "b1", "c1"], vec!["a2"]];
+		let result = rotate_nested_vectors(a).collect::<Vec<_>>();
 
-        let expected = vec!["a0", "a1", "a2", "b1", "c1"];
-        assert_eq!(expected, result);
+		let expected = vec!["a0", "a1", "a2", "b1", "c1"];
+		assert_eq!(expected, result);
 
-        // test single nested vector with a single value
-        let a = vec![vec!["a0"]];
-        let result = rotate_nested_vectors(a).collect::<Vec<_>>();
+		// test single nested vector with a single value
+		let a = vec![vec!["a0"]];
+		let result = rotate_nested_vectors(a).collect::<Vec<_>>();
 
-        let expected = vec!["a0"];
-        assert_eq!(expected, result);
+		let expected = vec!["a0"];
+		assert_eq!(expected, result);
 
-        // test single empty nested vector
-        let a:Vec<Vec<&str>> = vec![vec![]];
-        let result = rotate_nested_vectors(a).collect::<Vec<_>>();
-        let expected:Vec<&str> = vec![];
+		// test single empty nested vector
+		let a:Vec<Vec<&str>> = vec![vec![]];
+		let result = rotate_nested_vectors(a).collect::<Vec<_>>();
+		let expected:Vec<&str> = vec![];
 
-        assert_eq!(expected, result);
+		assert_eq!(expected, result);
 
-        // test first nested vector is empty
-        let a = vec![vec![], vec!["a1", "b1", "c1"]];
-        let result = rotate_nested_vectors(a).collect::<Vec<_>>();
+		// test first nested vector is empty
+		let a = vec![vec![], vec!["a1", "b1", "c1"]];
+		let result = rotate_nested_vectors(a).collect::<Vec<_>>();
 
-        let expected = vec!["a1", "b1", "c1"];
-        assert_eq!(expected, result);
+		let expected = vec!["a1", "b1", "c1"];
+		assert_eq!(expected, result);
 
-        // test two empty vectors
-        let a:Vec<Vec<&str>> = vec![vec![], vec![]];
-        let result = rotate_nested_vectors(a).collect::<Vec<_>>();
+		// test two empty vectors
+		let a:Vec<Vec<&str>> = vec![vec![], vec![]];
+		let result = rotate_nested_vectors(a).collect::<Vec<_>>();
 
-        let expected:Vec<&str> = vec![];
-        assert_eq!(expected, result);
+		let expected:Vec<&str> = vec![];
+		assert_eq!(expected, result);
 
-        // test an empty vector amongst other filled vectors
-        let a = vec![
-            vec!["a0", "b0", "c0"],
-            vec![],
-            vec!["a1", "b1", "c1"],
-            vec!["a2", "b2", "c2"],
-        ];
-        let result = rotate_nested_vectors(a).collect::<Vec<_>>();
+		// test an empty vector amongst other filled vectors
+		let a = vec![
+			vec!["a0", "b0", "c0"],
+			vec![],
+			vec!["a1", "b1", "c1"],
+			vec!["a2", "b2", "c2"],
+		];
+		let result = rotate_nested_vectors(a).collect::<Vec<_>>();
 
-        let expected = vec!["a0", "a1", "a2", "b0", "b1", "b2", "c0", "c1", "c2"];
-        assert_eq!(expected, result);
+		let expected = vec!["a0", "a1", "a2", "b0", "b1", "b2", "c0", "c1", "c2"];
+		assert_eq!(expected, result);
 
-        // test a filled vector between two empty vectors
-        let a = vec![vec![], vec!["a1", "b1", "c1"], vec![]];
-        let result = rotate_nested_vectors(a).collect::<Vec<_>>();
+		// test a filled vector between two empty vectors
+		let a = vec![vec![], vec!["a1", "b1", "c1"], vec![]];
+		let result = rotate_nested_vectors(a).collect::<Vec<_>>();
 
-        let expected = vec!["a1", "b1", "c1"];
-        assert_eq!(expected, result);
+		let expected = vec!["a1", "b1", "c1"];
+		assert_eq!(expected, result);
 
-        // test an empty vector at the end of the vectors
-        let a = vec![vec!["a0", "b0", "c0"], vec![]];
-        let result = rotate_nested_vectors(a).collect::<Vec<_>>();
+		// test an empty vector at the end of the vectors
+		let a = vec![vec!["a0", "b0", "c0"], vec![]];
+		let result = rotate_nested_vectors(a).collect::<Vec<_>>();
 
-        let expected = vec!["a0", "b0", "c0"];
-        assert_eq!(expected, result);
+		let expected = vec!["a0", "b0", "c0"];
+		assert_eq!(expected, result);
 
-        // test multiple empty vectors amongst multiple filled vectors
-        let a = vec![
-            vec![],
-            vec!["a1", "b1", "c1"],
-            vec![],
-            vec!["a3", "b3"],
-            vec![],
-        ];
+		// test multiple empty vectors amongst multiple filled vectors
+		let a = vec![
+			vec![],
+			vec!["a1", "b1", "c1"],
+			vec![],
+			vec!["a3", "b3"],
+			vec![],
+		];
 
-        let result = rotate_nested_vectors(a).collect::<Vec<_>>();
+		let result = rotate_nested_vectors(a).collect::<Vec<_>>();
 
-        let expected = vec!["a1", "a3", "b1", "b3", "c1"];
-        assert_eq!(expected, result);
+		let expected = vec!["a1", "a3", "b1", "b3", "c1"];
+		assert_eq!(expected, result);
 
-        // test one element in the first nested vectore and two elements in the second nested
-        // vector
-        let a = vec![vec!["a0"], vec!["a1", "b1"]];
-        let result = rotate_nested_vectors(a).collect::<Vec<_>>();
+		// test one element in the first nested vectore and two elements in the second nested
+		// vector
+		let a = vec![vec!["a0"], vec!["a1", "b1"]];
+		let result = rotate_nested_vectors(a).collect::<Vec<_>>();
 
-        let expected = vec!["a0", "a1", "b1"];
-        assert_eq!(expected, result);
-    }
+		let expected = vec!["a0", "a1", "b1"];
+		assert_eq!(expected, result);
+	}
 }