Don't duplicate fast int code in each generic copy

Closes jam1garner#319.

Author: ScanMountGoat

binrw/src/helpers.rs

@@ -612,43 +612,7 @@ fn not_enough_bytes<T>(_: T) -> Error {
 macro_rules! vec_fast_int {
     (try ($($Ty:ty)+) using ($list:expr, $reader:expr, $endian:expr, $count:expr) else { $($else:tt)* }) => {
         $(if let Some(list) = <dyn core::any::Any>::downcast_mut::<Vec<$Ty>>(&mut $list) {
-            let mut start = 0;
-            let mut remaining = $count;
-            // Allocating and reading from the source in chunks is done to keep
-            // a bad `count` from causing huge memory allocations that are
-            // doomed to fail
-            while remaining != 0 {
-                // Using a similar strategy as std `default_read_to_end` to
-                // leverage the memory growth strategy of the underlying Vec
-                // implementation (in std this will be exponential) using a
-                // minimum byte allocation
-                const GROWTH: usize = 32 / core::mem::size_of::<$Ty>();
-                list.reserve(remaining.min(GROWTH.max(1)));
-
-                let items_to_read = remaining.min(list.capacity() - start);
-                let end = start + items_to_read;
-
-                // In benchmarks, this resize decreases performance by 27–40%
-                // relative to using `unsafe` to write directly to uninitialised
-                // memory, but nobody ever got fired for buying IBM
-                list.resize(end, 0);
-                $reader.read_exact(&mut bytemuck::cast_slice_mut::<_, u8>(&mut list[start..end]))?;
-
-                remaining -= items_to_read;
-                start += items_to_read;
-            }
-
-            if
-                core::mem::size_of::<$Ty>() != 1
-                && (
-                    (cfg!(target_endian = "big") && $endian == crate::Endian::Little)
-                    || (cfg!(target_endian = "little") && $endian == crate::Endian::Big)
-                )
-            {
-                for value in list.iter_mut() {
-                    *value = value.swap_bytes();
-                }
-            }
+            read_vec_fast_int($reader, $count, $endian, list)?;
             Ok($list)
         } else)* {
             $($else)*
@@ -657,3 +621,68 @@ macro_rules! vec_fast_int {
 }
 
 use vec_fast_int;
+
+trait SwapBytes {
+    fn swap_bytes(self) -> Self;
+}
+
+macro_rules! swap_bytes_impl {
+    ($($ty:ty),*) => {
+        $(
+            impl SwapBytes for $ty {
+                #[inline(always)]
+                fn swap_bytes(self) -> Self {
+                    <$ty>::swap_bytes(self)
+                }
+            }
+        )*
+    };
+}
+swap_bytes_impl!(i8, i16, u16, i32, u32, i64, u64, i128, u128);
+
+fn read_vec_fast_int<T, R>(
+    reader: &mut R,
+    count: usize,
+    endian: Endian,
+    list: &mut Vec<T>,
+) -> BinResult<()>
+where
+    R: Read,
+    T: Clone + Default + bytemuck::Pod + SwapBytes,
+{
+    let mut start = 0;
+    let mut remaining = count;
+    // Allocating and reading from the source in chunks is done to keep
+    // a bad `count` from causing huge memory allocations that are
+    // doomed to fail
+    while remaining != 0 {
+        // Using a similar strategy as std `default_read_to_end` to
+        // leverage the memory growth strategy of the underlying Vec
+        // implementation (in std this will be exponential) using a
+        // minimum byte allocation
+        let growth = 32 / core::mem::size_of::<T>();
+        list.reserve(remaining.min(growth.max(1)));
+
+        let items_to_read = remaining.min(list.capacity() - start);
+        let end = start + items_to_read;
+
+        // In benchmarks, this resize decreases performance by 27–40%
+        // relative to using `unsafe` to write directly to uninitialised
+        // memory, but nobody ever got fired for buying IBM
+        list.resize(end, T::default());
+        reader.read_exact(bytemuck::cast_slice_mut::<_, u8>(&mut list[start..end]))?;
+
+        remaining -= items_to_read;
+        start += items_to_read;
+    }
+
+    if core::mem::size_of::<T>() != 1
+        && ((cfg!(target_endian = "big") && endian == crate::Endian::Little)
+            || (cfg!(target_endian = "little") && endian == crate::Endian::Big))
+    {
+        for value in list.iter_mut() {
+            *value = value.swap_bytes();
+        }
+    }
+    Ok(())
+}