Changing naming in rotate function to reference iterators rather than

vectors

Author: upjohnc

lightning-invoice/src/utils.rs

@@ -282,16 +282,16 @@ 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_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> {
+/// Draw items iteratively from multiple nested iterators.  The items are retrieved by index and
+/// rotates through the nested iterators - first the zero index then the first index then second index, etc.
+fn rotate_nested_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;
@@ -302,9 +302,9 @@ fn rotate_nested_vectors<T, I: Iterator<Item = T>>(mut vecs: Vec<I>) -> impl Ite
 				return Some(item);
 			}
 			// exhausted_vectors increase when the "next_idx" vector is exhausted
-			exhausted_vectors += 1;
+			exhausted_iterators += 1;
 			// return None when all of the nested vectors are exhausted
-			if exhausted_vectors > vecs.len() {
+			if exhausted_iterators == vecs.len() {
 				return None;
 			}
 		}
@@ -803,7 +803,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_nested_iterators};
 	use std::collections::HashSet;
 
 	#[test]
@@ -1914,59 +1914,59 @@ mod test {
 	}
 
 	#[test]
-	fn test_zip_nested_vectors() {
+	fn test_rotate_nested_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_nested_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_nested_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_nested_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_nested_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_nested_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_nested_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_nested_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_nested_iterators(a).collect::<Vec<&str>>();
 
 		let expected:Vec<&str> = vec![];
 		assert_eq!(expected, result);
@@ -1978,21 +1978,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_nested_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_nested_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_nested_iterators(a).collect::<Vec<_>>();
 
 		let expected = vec!["a0", "b0", "c0"];
 		assert_eq!(expected, result);
@@ -2006,15 +2006,15 @@ mod test {
 			vec![].into_iter(),
 		];
 
-		let result = rotate_nested_vectors(a).collect::<Vec<_>>();
+		let result = rotate_nested_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_nested_iterators(a).collect::<Vec<_>>();
 
 		let expected = vec!["a0", "a1", "b1"];
 		assert_eq!(expected, result);