Add from() constructor reading file with offset and length parameter

fixes #25

Author: patrickfav

CHANGELOG

@@ -7,6 +7,7 @@
 * add constructor for `IntBuffer` and `CharBuffer`
 * `parse()` methods now expect more flexible `CharSequence` instead of `String` #23
 * `from()` constructor reading from `char[]` has new version that accepts offset and length #24
+* add `from()` constructor reading file with offset and length parameter #25
 
 ### Breaking
 

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

@@ -470,6 +470,21 @@ public static Bytes from(File file) {
         return wrap(Util.readFromFile(file));
     }
 
+    /**
+     * Reads given file and returns the byte content. Be aware that the whole defined file content will be loaded to
+     * memory, so be careful what to read in. This uses {@link java.io.RandomAccessFile} under the hood.
+     *
+     * @param file   to read from
+     * @param offset byte offset from zero position of the file
+     * @param length to read from offset
+     * @return new instance
+     * @throws IllegalArgumentException if file does not exist
+     * @throws IllegalStateException    if file could not be read
+     */
+    public static Bytes from(File file, int offset, int length) {
+        return wrap(Util.readFromFile(file, offset, length));
+    }
+
     /**
      * Creates a new instance from given utf-8 encoded string
      *

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

@@ -26,6 +26,7 @@
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.RandomAccessFile;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 import java.nio.CharBuffer;
@@ -378,9 +379,7 @@ static byte[] concatVararg(byte firstByte, byte[] moreBytes) {
      * @return byte content
      */
     static byte[] readFromFile(File file) {
-        if (file == null || !file.exists() || !file.isFile()) {
-            throw new IllegalArgumentException("file must not be null, has to exist and must be a file (not a directory) " + file);
-        }
+        checkFile(file);
 
         try {
             return Files.readAllBytes(file.toPath());
@@ -389,6 +388,30 @@ static byte[] readFromFile(File file) {
         }
     }
 
+    /**
+     * Reads bytes from file with given offset and max length
+     *
+     * @param file   to read bytes from
+     * @param offset to read
+     * @param length from offset
+     * @return byte array with length length
+     */
+    static byte[] readFromFile(File file, int offset, int length) {
+        checkFile(file);
+        try (RandomAccessFile raf = new RandomAccessFile(file, "r")) {
+            raf.seek(offset);
+            return readFromDataInput(raf, length);
+        } catch (Exception e) {
+            throw new IllegalStateException("could not read from random access file", e);
+        }
+    }
+
+    private static void checkFile(File file) {
+        if (file == null || !file.exists() || !file.isFile()) {
+            throw new IllegalArgumentException("file must not be null, has to exist and must be a file (not a directory) " + file);
+        }
+    }
+
     /**
      * Converts a char array to a byte array with given charset and range
      *

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

@@ -456,7 +456,44 @@ public void fromFileCannotRead() throws Exception {
         try {
             Bytes.from(tempFile);
             fail();
-        } catch (IllegalStateException e) {
+        } catch (IllegalStateException ignored) {
+        }
+    }
+
+    @Test
+    public void fromFileOffset() throws Exception {
+        File tempFile = testFolder.newFile("out-test2.txt");
+        Bytes bytes = Bytes.wrap(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18});
+        try (FileOutputStream stream = new FileOutputStream(tempFile)) {
+            stream.write(bytes.array());
+        }
+
+        for (int lenI = 1; lenI < bytes.length() + 1; lenI++) {
+            for (int offsetI = 0; offsetI < bytes.length(); offsetI++) {
+                if (offsetI + lenI > bytes.length()) break;
+                assertEquals(bytes.copy(offsetI, lenI), Bytes.from(tempFile, offsetI, lenI));
+            }
+        }
+        assertEquals(Bytes.from(tempFile), Bytes.from(tempFile, 0, (int) tempFile.length()));
+    }
+
+    @Test
+    public void fromFileOffsetWithIllegalOffsetOrLength() throws Exception {
+        File tempFile = testFolder.newFile("fromFileOffsetWithIllegalOffsetOrLength.txt");
+        try (FileOutputStream stream = new FileOutputStream(tempFile)) {
+            stream.write(new byte[]{0, 1, 2, 3});
+        }
+
+        try {
+            Bytes.from(tempFile, 0, 5);
+            fail();
+        } catch (IllegalStateException ignored) {
+        }
+
+        try {
+            Bytes.from(tempFile, 5, 1);
+            fail();
+        } catch (IllegalStateException ignored) {
         }
     }