Add startsWith() and endsWidth() methods

refs #12

Author: patrickfav

CHANGELOG

@@ -8,6 +8,7 @@
  * add indexOf() with `fromIndex` parameter #14
  * add support for base64 url safe encoding #15
  * use EMPTY constant instance for empty byte array to safe memory #16
+ * add `startsWith()` and `endsWidth()` methods #12
 
 ## v0.6.0
 

README.md

@@ -352,8 +352,11 @@ Finding occurrence of specific bytes:
 ```java
 Bytes.wrap(array).contains((byte) 0xE1);
 Bytes.wrap(array).indexOf((byte) 0xFD);
+Bytes.wrap(array).indexOf(new byte[] {(byte) 0xFD, 0x23});
 Bytes.wrap(array).indexOf((byte) 0xFD, 5); //search fromIndex 5
 Bytes.wrap(array).lastIndexOf((byte) 0xAE);
+Bytes.wrap(array).startsWith(new byte[] {(byte) 0xAE, 0x32});
+Bytes.wrap(array).endsWidth(new byte[] {(byte) 0xAE, 0x23});
 ```
 
 Length checks:

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

@@ -1120,7 +1120,7 @@ public int indexOf(byte target) {
      * {@code -1} if no such index exists or fromIndex is gt target length.
      */
     public int indexOf(byte target, int fromIndex) {
-        return Util.indexOf(internalArray(), new byte[]{target}, fromIndex);
+        return indexOf(new byte[]{target}, fromIndex);
     }
 
     /**
@@ -1136,7 +1136,7 @@ public int indexOf(byte target, int fromIndex) {
      * {@code -1} if no such index exists.
      */
     public int indexOf(byte[] subArray) {
-        return Util.indexOf(internalArray(), subArray, 0);
+        return indexOf(subArray, 0);
     }
 
     /**
@@ -1154,7 +1154,18 @@ public int indexOf(byte[] subArray) {
      * {@code -1} if no such index exists.
      */
     public int indexOf(byte[] subArray, int fromIndex) {
-        return Util.indexOf(internalArray(), subArray, fromIndex);
+        return Util.indexOf(internalArray(), subArray, fromIndex, length());
+    }
+
+    /**
+     * Checks if the given sub array is equal to the start of given array. That is, sub array must be gt or eq
+     * to the length of the internal array and <code>internal[i] == subArray[i]</code> for i=0..subArray.length-1
+     *
+     * @param subArray to check against the start of the internal array
+     * @return true if the start of the internal array is eq to given sub array
+     */
+    public boolean startsWith(byte[] subArray) {
+        return Util.indexOf(internalArray(), subArray, 0, 1) == 0;
     }
 
     /**
@@ -1169,6 +1180,18 @@ public int lastIndexOf(byte target) {
         return Util.lastIndexOf(internalArray(), target, 0, length());
     }
 
+    /**
+     * Checks if the given sub array is equal to the end of given array. That is, sub array must be gt or eq
+     * to the length of the internal array and <code>internal[i] == subArray[i]</code> for i=subArray.length...internal.length
+     *
+     * @param subArray to check against the end of the internal array
+     * @return true if the end of the internal array is eq to given sub array
+     */
+    public boolean endsWith(byte[] subArray) {
+        int startIndex = length() - subArray.length;
+        return startIndex >= 0 && Util.indexOf(internalArray(), subArray, startIndex, startIndex + 1) == startIndex;
+    }
+
     /**
      * Returns the {@code bit} value as boolean at the specified index. Bit index 0 is the LSB, so for example byte word
      * <code>1000 0000</code> has <code>bitAt(0) == false</code> and <code>bitAt(7) == true</code>.

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

@@ -67,15 +67,15 @@ static byte[] concat(byte[]... arrays) {
      * @param array  the array to search for the sequence {@code target}
      * @param target the array to search for as a sub-sequence of {@code array}
      */
-    static int indexOf(byte[] array, byte[] target, int start) {
+    static int indexOf(byte[] array, byte[] target, int start, int end) {
         Objects.requireNonNull(array, "array must not be null");
         Objects.requireNonNull(target, "target must not be null");
-        if (target.length == 0) {
+        if (target.length == 0 || start < 0) {
             return -1;
         }
 
         outer:
-        for (int i = start; i < array.length - target.length + 1; i++) {
+        for (int i = start; i < Math.min(end, array.length - target.length + 1); i++) {
             for (int j = 0; j < target.length; j++) {
                 if (array[i + j] != target[j]) {
                     continue outer;

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

@@ -190,6 +190,32 @@ public void indexOfArrayFromIndex() {
         assertEquals(2, Bytes.from(new byte[]{(byte) 0x8E, (byte) 0xD1, (byte) 0x8E, (byte) 0xD1, 0x12, (byte) 0xAF, (byte) 0x78, 0x09, 0x1E, (byte) 0xD1, (byte) 0xFD, (byte) 0xAA, 0x12}).indexOf(new byte[]{(byte) 0x8E, (byte) 0xD1}, 1));
     }
 
+    @Test
+    public void startsWidth() {
+        assertFalse(Bytes.allocate(0).startsWith(new byte[1]));
+        assertTrue(Bytes.allocate(1).startsWith(new byte[1]));
+        assertTrue(Bytes.allocate(128).startsWith(new byte[1]));
+        assertTrue(Bytes.allocate(128).startsWith(new byte[128]));
+        assertTrue(Bytes.from(example_bytes_seven).startsWith(new byte[]{0x4A}));
+        assertTrue(Bytes.from(example_bytes_seven).startsWith(new byte[]{0x4A, (byte) 0x94}));
+        assertTrue(Bytes.from(example_bytes_seven).startsWith(new byte[]{0x4A, (byte) 0x94, (byte) 0xFD}));
+        assertFalse(Bytes.from(example_bytes_seven).startsWith(new byte[]{0x4A, (byte) 0x94, (byte) 0x1D}));
+        assertTrue(Bytes.from(example_bytes_seven).startsWith(Bytes.from(example_bytes_seven).array()));
+        assertFalse(Bytes.from(example_bytes_seven).startsWith(Bytes.from(example_bytes_seven).append(0x30).array()));
+    }
+
+    @Test
+    public void endsWith() {
+        assertTrue(Bytes.from(example_bytes_seven).endsWith(new byte[]{(byte) 0xFF, 0x1E, (byte) 0xAF, (byte) 0xED}));
+        assertTrue(Bytes.from(example_bytes_seven).endsWith(new byte[]{0x1E, (byte) 0xAF, (byte) 0xED}));
+        assertTrue(Bytes.from(example_bytes_seven).endsWith(new byte[]{(byte) 0xAF, (byte) 0xED}));
+        assertTrue(Bytes.from(example_bytes_seven).endsWith(new byte[]{(byte) 0xED}));
+        assertFalse(Bytes.allocate(0).endsWith(new byte[1]));
+        assertTrue(Bytes.allocate(1).endsWith(new byte[1]));
+        assertTrue(Bytes.allocate(128).endsWith(new byte[1]));
+        assertTrue(Bytes.allocate(128).endsWith(new byte[128]));
+    }
+
     @Test
     public void lastIndexOf() {
         assertEquals(-1, Bytes.allocate(0).lastIndexOf((byte) 0xFD));

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

@@ -53,39 +53,39 @@ public void testIndexOf() {
     }
 
     private int indexOf(byte[] empty, byte b) {
-        return Util.indexOf(empty, new byte[]{b}, 0);
+        return Util.indexOf(empty, new byte[]{b}, 0, empty.length);
     }
 
     @Test
     public void testIndexOf_arrayTarget() {
-        assertEquals(-1, Util.indexOf(EMPTY, EMPTY, 0));
-        assertEquals(-1, Util.indexOf(ARRAY234, EMPTY, 0));
-        assertEquals(-1, Util.indexOf(EMPTY, ARRAY234, 0));
-        assertEquals(-1, Util.indexOf(ARRAY234, ARRAY1, 0));
-        assertEquals(-1, Util.indexOf(ARRAY1, ARRAY234, 0));
-        assertEquals(0, Util.indexOf(ARRAY1, ARRAY1, 0));
-        assertEquals(0, Util.indexOf(ARRAY234, ARRAY234, 0));
+        assertEquals(-1, Util.indexOf(EMPTY, EMPTY, 0, EMPTY.length));
+        assertEquals(-1, Util.indexOf(ARRAY234, EMPTY, 0, ARRAY234.length));
+        assertEquals(-1, Util.indexOf(EMPTY, ARRAY234, 0, EMPTY.length));
+        assertEquals(-1, Util.indexOf(ARRAY234, ARRAY1, 0, ARRAY234.length));
+        assertEquals(-1, Util.indexOf(ARRAY1, ARRAY234, 0, ARRAY1.length));
+        assertEquals(0, Util.indexOf(ARRAY1, ARRAY1, 0, ARRAY1.length));
+        assertEquals(0, Util.indexOf(ARRAY234, ARRAY234, 0, ARRAY234.length));
         assertEquals(0, Util.indexOf(
-                ARRAY234, new byte[]{(byte) 2, (byte) 3}, 0));
+                ARRAY234, new byte[]{(byte) 2, (byte) 3}, 0, 2));
         assertEquals(1, Util.indexOf(
-                ARRAY234, new byte[]{(byte) 3, (byte) 4}, 0));
-        assertEquals(1, Util.indexOf(ARRAY234, new byte[]{(byte) 3}, 0));
-        assertEquals(2, Util.indexOf(ARRAY234, new byte[]{(byte) 4}, 0));
-        assertEquals(1, Util.indexOf(new byte[]{(byte) 2, (byte) 3, (byte) 3, (byte) 3, (byte) 3}, new byte[]{(byte) 3}, 0));
+                ARRAY234, new byte[]{(byte) 3, (byte) 4}, 0, 2));
+        assertEquals(1, Util.indexOf(ARRAY234, new byte[]{(byte) 3}, 0, ARRAY234.length));
+        assertEquals(2, Util.indexOf(ARRAY234, new byte[]{(byte) 4}, 0, ARRAY234.length));
+        assertEquals(1, Util.indexOf(new byte[]{(byte) 2, (byte) 3, (byte) 3, (byte) 3, (byte) 3}, new byte[]{(byte) 3}, 0, 5));
         assertEquals(2, Util.indexOf(
                 new byte[]{(byte) 2, (byte) 3, (byte) 2,
                         (byte) 3, (byte) 4, (byte) 2, (byte) 3},
                 new byte[]{(byte) 2, (byte) 3, (byte) 4}
-                , 0));
+                , 0, 7));
         assertEquals(1, Util.indexOf(
                 new byte[]{(byte) 2, (byte) 2, (byte) 3,
                         (byte) 4, (byte) 2, (byte) 3, (byte) 4},
                 new byte[]{(byte) 2, (byte) 3, (byte) 4}
-                , 0));
+                , 0, 7));
         assertEquals(-1, Util.indexOf(
                 new byte[]{(byte) 4, (byte) 3, (byte) 2},
                 new byte[]{(byte) 2, (byte) 3, (byte) 4}
-                , 0));
+                , 0, 2));
     }
 
     @Test