Use reverse guava implementation

Author: patrickfav

src/main/java/at/favre/lib/bytes/BytesTransformer.java

@@ -192,12 +192,7 @@ final class ReverseTransformer implements BytesTransformer {
         @Override
         public byte[] transform(byte[] currentArray, boolean inPlace) {
             byte[] out = inPlace ? currentArray : Bytes.from(currentArray).array();
-
-            for (int i = 0; i < out.length / 2; i++) {
-                byte temp = out[i];
-                out[i] = out[out.length - i - 1];
-                out[out.length - i - 1] = temp;
-            }
+            Util.reverse(out, 0, out.length);
             return out;
         }
 

src/main/java/at/favre/lib/bytes/Util.java

@@ -244,6 +244,24 @@ static void shuffle(byte[] array, Random random) {
         }
     }
 
+    /**
+     * Reverses the elements of {@code array} between {@code fromIndex} inclusive and {@code toIndex}
+     * exclusive. This is equivalent to {@code
+     * Collections.reverse(Bytes.asList(array).subList(fromIndex, toIndex))}, but is likely to be more
+     * efficient.
+     *
+     * @throws IndexOutOfBoundsException if {@code fromIndex < 0}, {@code toIndex > array.length}, or
+     *                                   {@code toIndex > fromIndex}
+     */
+    static void reverse(byte[] array, int fromIndex, int toIndex) {
+        Objects.requireNonNull(array);
+        for (int i = fromIndex, j = toIndex - 1; i < j; i++, j--) {
+            byte tmp = array[i];
+            array[i] = array[j];
+            array[j] = tmp;
+        }
+    }
+
     private static final int BUF_SIZE = 0x1000; // 4K
 
     /**

src/test/java/at/favre/lib/bytes/UtilTest.java

@@ -192,4 +192,35 @@ public void readFromStream() throws Exception {
     public void concatVararg() throws Exception {
         assertArrayEquals(new byte[]{1}, Util.concatVararg((byte) 1, null));
     }
+
+    @Test
+    public void testReverse() {
+        testReverse(new byte[]{}, new byte[]{});
+        testReverse(new byte[]{1}, new byte[]{1});
+        testReverse(new byte[]{1, 2}, new byte[]{2, 1});
+        testReverse(new byte[]{3, 1, 1}, new byte[]{1, 1, 3});
+        testReverse(new byte[]{-1, 1, -2, 2}, new byte[]{2, -2, 1, -1});
+    }
+
+    @Test
+    public void testReverseIndexed() {
+        testReverse(new byte[]{}, 0, 0, new byte[]{});
+        testReverse(new byte[]{1}, 0, 1, new byte[]{1});
+        testReverse(new byte[]{1, 2}, 0, 2, new byte[]{2, 1});
+        testReverse(new byte[]{3, 1, 1}, 0, 2, new byte[]{1, 3, 1});
+        testReverse(new byte[]{3, 1, 1}, 0, 1, new byte[]{3, 1, 1});
+        testReverse(new byte[]{-1, 1, -2, 2}, 1, 3, new byte[]{-1, -2, 1, 2});
+    }
+
+    private static void testReverse(byte[] input, byte[] expectedOutput) {
+        input = Arrays.copyOf(input, input.length);
+        Util.reverse(input, 0, input.length);
+        assertTrue(Arrays.equals(expectedOutput, input));
+    }
+
+    private static void testReverse(byte[] input, int fromIndex, int toIndex, byte[] expectedOutput) {
+        input = Arrays.copyOf(input, input.length);
+        Util.reverse(input, fromIndex, toIndex);
+        assertTrue(Arrays.equals(expectedOutput, input));
+    }
 }