Setting indentations to tabs

Author: upjohnc

lightning-invoice/src/utils.rs

@@ -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,12 +585,12 @@ 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,
+	channels: Vec<ChannelDetails>,
+	min_inbound_capacity_msat: Option<u64>,
+	logger: &L,
 ) -> impl Iterator<Item = RouteHint>
 where
-    L::Target: Logger,
+	L::Target: Logger,
 {
 	let mut filtered_channels: HashMap<PublicKey, ChannelDetails> = HashMap::new();
 	let min_inbound_capacity = min_inbound_capacity_msat.unwrap_or(0);
@@ -617,7 +617,7 @@ where
 				// 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![].into_iter().take(3).map(route_hint_from_channel);
+				return vec![].into_iter().take(3).map(route_hint_from_channel);
 			}
 		}
 
@@ -689,8 +689,7 @@ where
 			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
@@ -1905,110 +1904,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);
+	}
 }