Correct variable naming to express the loop functionality

of the two iterators in the `lightning-invoice/src/utils.rs` file

Author: upjohnc

lightning-invoice/src/utils.rs

@@ -276,37 +276,36 @@ where
 			});
 
 		phantom_hints.push(route_hints);
-
 	}
 
 	// We have one vector per real node involved in creating the phantom invoice. To distribute
 	// 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_through_iterators(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, I: Iterator<Item = T>>(mut vecs: Vec<I>) -> impl Iterator<Item = T> {
-	let mut idx = 0;
+/// Draw items iteratively from multiple iterators.  The items are retrieved by index and
+/// rotates through the iterators - first the zero index then the first index then second index, etc.
+fn rotate_through_iterators<T, I: Iterator<Item = T>>(mut vecs: Vec<I>) -> impl Iterator<Item = T> {
+	let mut iterations = 0;
 
 	core::iter::from_fn(move || {
-		let mut exhausted_vectors = 0;
+		let mut exhausted_iterators = 0;
 		loop {
 			if vecs.is_empty() {
 				return None;
 			}
-			let next_idx = idx % vecs.len();
-			let hint_opt = vecs[next_idx].next();
-			idx += 1;
-			if let Some(hint) = hint_opt {
-				return Some(hint);
+			let next_idx = iterations % vecs.len();
+			iterations += 1;
+			if let Some(item) = vecs[next_idx].next() {
+				return Some(item);
 			}
 			// exhausted_vectors increase when the "next_idx" vector is exhausted
-			exhausted_vectors += 1;
-			// return None when all of the nested vectors are exhausted
-			if exhausted_vectors > vecs.len() {
+			exhausted_iterators += 1;
+			// The check for exhausted iterators gets reset to 0 after each yield of `Some()`
+			// The lop will return None when all of the nested iterators are exhausted
+			if exhausted_iterators == vecs.len() {
 				return None;
 			}
 		}
@@ -805,7 +804,7 @@ mod test {
 	use lightning::routing::router::{PaymentParameters, RouteParameters};
 	use lightning::util::test_utils;
 	use lightning::util::config::UserConfig;
-	use crate::utils::{create_invoice_from_channelmanager_and_duration_since_epoch, rotate_nested_vectors};
+	use crate::utils::{create_invoice_from_channelmanager_and_duration_since_epoch, rotate_through_iterators};
 	use std::collections::HashSet;
 
 	#[test]
@@ -1915,61 +1914,60 @@ mod test {
 		}
 	}
 
-
 	#[test]
-	fn test_zip_nested_vectors() {
+	fn test_rotate_through_iterators() {
 		// two nested vectors
 		let a = vec![vec!["a0", "b0", "c0"].into_iter(), vec!["a1", "b1"].into_iter()];
-		let result = rotate_nested_vectors(a).collect::<Vec<_>>();
+		let result = rotate_through_iterators(a).collect::<Vec<_>>();
 
 		let expected = vec!["a0", "a1", "b0", "b1", "c0"];
 		assert_eq!(expected, result);
 
 		// test single nested vector
 		let a = vec![vec!["a0", "b0", "c0"].into_iter()];
-		let result = rotate_nested_vectors(a).collect::<Vec<_>>();
+		let result = rotate_through_iterators(a).collect::<Vec<_>>();
 
 		let expected = vec!["a0", "b0", "c0"];
 		assert_eq!(expected, result);
 
 		// test second vector with only one element
 		let a = vec![vec!["a0", "b0", "c0"].into_iter(), vec!["a1"].into_iter()];
-		let result = rotate_nested_vectors(a).collect::<Vec<_>>();
+		let result = rotate_through_iterators(a).collect::<Vec<_>>();
 
 		let expected = vec!["a0", "a1", "b0", "c0"];
 		assert_eq!(expected, result);
 
 		// test three nestend vectors
 		let a = vec![vec!["a0"].into_iter(), vec!["a1", "b1", "c1"].into_iter(), vec!["a2"].into_iter()];
-		let result = rotate_nested_vectors(a).collect::<Vec<_>>();
+		let result = rotate_through_iterators(a).collect::<Vec<_>>();
 
 		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"].into_iter()];
-		let result = rotate_nested_vectors(a).collect::<Vec<_>>();
+		let result = rotate_through_iterators(a).collect::<Vec<_>>();
 
 		let expected = vec!["a0"];
 		assert_eq!(expected, result);
 
 		// test single empty nested vector
 		let a:Vec<std::vec::IntoIter<&str>> = vec![vec![].into_iter()];
-		let result = rotate_nested_vectors(a).collect::<Vec<&str>>();
+		let result = rotate_through_iterators(a).collect::<Vec<&str>>();
 		let expected:Vec<&str> = vec![];
 
 		assert_eq!(expected, result);
 
 		// test first nested vector is empty
 		let a:Vec<std::vec::IntoIter<&str>>= vec![vec![].into_iter(), vec!["a1", "b1", "c1"].into_iter()];
-		let result = rotate_nested_vectors(a).collect::<Vec<&str>>();
+		let result = rotate_through_iterators(a).collect::<Vec<&str>>();
 
 		let expected = vec!["a1", "b1", "c1"];
 		assert_eq!(expected, result);
 
 		// test two empty vectors
 		let a:Vec<std::vec::IntoIter<&str>> = vec![vec![].into_iter(), vec![].into_iter()];
-		let result = rotate_nested_vectors(a).collect::<Vec<&str>>();
+		let result = rotate_through_iterators(a).collect::<Vec<&str>>();
 
 		let expected:Vec<&str> = vec![];
 		assert_eq!(expected, result);
@@ -1981,21 +1979,21 @@ mod test {
 			vec!["a1", "b1", "c1"].into_iter(),
 			vec!["a2", "b2", "c2"].into_iter(),
 		];
-		let result = rotate_nested_vectors(a).collect::<Vec<_>>();
+		let result = rotate_through_iterators(a).collect::<Vec<_>>();
 
 		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![].into_iter(), vec!["a1", "b1", "c1"].into_iter(), vec![].into_iter()];
-		let result = rotate_nested_vectors(a).collect::<Vec<_>>();
+		let result = rotate_through_iterators(a).collect::<Vec<_>>();
 
 		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"].into_iter(), vec![].into_iter()];
-		let result = rotate_nested_vectors(a).collect::<Vec<_>>();
+		let result = rotate_through_iterators(a).collect::<Vec<_>>();
 
 		let expected = vec!["a0", "b0", "c0"];
 		assert_eq!(expected, result);
@@ -2009,15 +2007,15 @@ mod test {
 			vec![].into_iter(),
 		];
 
-		let result = rotate_nested_vectors(a).collect::<Vec<_>>();
+		let result = rotate_through_iterators(a).collect::<Vec<_>>();
 
 		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"].into_iter(), vec!["a1", "b1"].into_iter()];
-		let result = rotate_nested_vectors(a).collect::<Vec<_>>();
+		let result = rotate_through_iterators(a).collect::<Vec<_>>();
 
 		let expected = vec!["a0", "a1", "b1"];
 		assert_eq!(expected, result);