New upstream version 1.48.0~beta.8+dfsg1

[rustc.git] / vendor / generic-array / src / hex.rs

diff --git a/vendor/generic-array/src/hex.rs b/vendor/generic-array/src/hex.rs
index 09a6608e37ce07fc1c30383a38a38313d3aa361e..33c796f3c9c2cddd842f0c341bb6887c527828c5 100644 (file)
--- a/vendor/generic-array/src/hex.rs
+++ b/vendor/generic-array/src/hex.rs
@@ -15,13 +15,12 @@
 //! ```\r
 //!\r
 \r
-use {ArrayLength, GenericArray};\r
-use core::cmp::min;\r
-use core::fmt;\r
-use core::ops::Add;\r
-use core::str;\r
+use core::{fmt, str, ops::Add, cmp::min};\r
+\r
 use typenum::*;\r
 \r
+use crate::{ArrayLength, GenericArray};\r
+\r
 static LOWER_CHARS: &'static [u8] = b"0123456789abcdef";\r
 static UPPER_CHARS: &'static [u8] = b"0123456789ABCDEF";\r
 \r
@@ -30,19 +29,20 @@ where
     T: Add<T>,\r
     <T as Add<T>>::Output: ArrayLength<u8>,\r
 {\r
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\r
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\r
         let max_digits = f.precision().unwrap_or_else(|| self.len() * 2);\r
         let max_hex = (max_digits >> 1) + (max_digits & 1);\r
 \r
-        if T::to_usize() < 1024 {\r
+        if T::USIZE < 1024 {\r
             // For small arrays use a stack allocated\r
             // buffer of 2x number of bytes\r
             let mut res = GenericArray::<u8, Sum<T, T>>::default();\r
 \r
-            for (i, c) in self.iter().take(max_hex).enumerate() {\r
+            self.iter().take(max_hex).enumerate().for_each(|(i, c)| {\r
                 res[i * 2] = LOWER_CHARS[(c >> 4) as usize];\r
                 res[i * 2 + 1] = LOWER_CHARS[(c & 0xF) as usize];\r
-            }\r
+            });\r
+\r
             f.write_str(unsafe { str::from_utf8_unchecked(&res[..max_digits]) })?;\r
         } else {\r
             // For large array use chunks of up to 1024 bytes (2048 hex chars)\r
@@ -50,10 +50,11 @@ where
             let mut digits_left = max_digits;\r
 \r
             for chunk in self[..max_hex].chunks(1024) {\r
-                for (i, c) in chunk.iter().enumerate() {\r
+                chunk.iter().enumerate().for_each(|(i, c)| {\r
                     buf[i * 2] = LOWER_CHARS[(c >> 4) as usize];\r
                     buf[i * 2 + 1] = LOWER_CHARS[(c & 0xF) as usize];\r
-                }\r
+                });\r
+\r
                 let n = min(chunk.len() * 2, digits_left);\r
                 f.write_str(unsafe { str::from_utf8_unchecked(&buf[..n]) })?;\r
                 digits_left -= n;\r
@@ -68,19 +69,20 @@ where
     T: Add<T>,\r
     <T as Add<T>>::Output: ArrayLength<u8>,\r
 {\r
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\r
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\r
         let max_digits = f.precision().unwrap_or_else(|| self.len() * 2);\r
         let max_hex = (max_digits >> 1) + (max_digits & 1);\r
 \r
-        if T::to_usize() < 1024 {\r
+        if T::USIZE < 1024 {\r
             // For small arrays use a stack allocated\r
             // buffer of 2x number of bytes\r
             let mut res = GenericArray::<u8, Sum<T, T>>::default();\r
 \r
-            for (i, c) in self.iter().take(max_hex).enumerate() {\r
+            self.iter().take(max_hex).enumerate().for_each(|(i, c)| {\r
                 res[i * 2] = UPPER_CHARS[(c >> 4) as usize];\r
                 res[i * 2 + 1] = UPPER_CHARS[(c & 0xF) as usize];\r
-            }\r
+            });\r
+\r
             f.write_str(unsafe { str::from_utf8_unchecked(&res[..max_digits]) })?;\r
         } else {\r
             // For large array use chunks of up to 1024 bytes (2048 hex chars)\r
@@ -88,10 +90,11 @@ where
             let mut digits_left = max_digits;\r
 \r
             for chunk in self[..max_hex].chunks(1024) {\r
-                for (i, c) in chunk.iter().enumerate() {\r
+                chunk.iter().enumerate().for_each(|(i, c)| {\r
                     buf[i * 2] = UPPER_CHARS[(c >> 4) as usize];\r
                     buf[i * 2 + 1] = UPPER_CHARS[(c & 0xF) as usize];\r
-                }\r
+                });\r
+\r
                 let n = min(chunk.len() * 2, digits_left);\r
                 f.write_str(unsafe { str::from_utf8_unchecked(&buf[..n]) })?;\r
                 digits_left -= n;\r