Add new from() constructor using char[] which accept offset + length

fixes #24

Author: patrickfav

CHANGELOG

@@ -6,6 +6,7 @@
 * add support for Base32 RFC4648 non-hex alphabet encoding/parsing #21
 * 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
 
 ### Breaking
 

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

@@ -199,7 +199,7 @@ public static Bytes fromNullSafe(byte[] byteArrayToCopy) {
      * Creates a new instance from a slice of given array
      *
      * @param array  to slice
-     * @param offset stat position
+     * @param offset start position
      * @param length length
      * @return new instance
      */
@@ -520,10 +520,20 @@ public static Bytes from(char[] charArray) {
      * @return new instance
      */
     public static Bytes from(char[] charArray, Charset charset) {
-        ByteBuffer bb = charset.encode(CharBuffer.wrap(charArray));
-        byte[] bytes = new byte[bb.remaining()];
-        bb.get(bytes);
-        return from(bytes);
+        return from(charArray, charset, 0, charArray.length);
+    }
+
+    /**
+     * Creates a new instance from given char array with given range. The array will be handles like an encoded string
+     *
+     * @param charArray to get the internal byte array from
+     * @param charset   charset to be used to decode the char array
+     * @param offset    start position (from given char array not encoded byte array out)
+     * @param length    length in relation to offset (from given char array not encoded byte array out)
+     * @return new instance
+     */
+    public static Bytes from(char[] charArray, Charset charset, int offset, int length) {
+        return from(Util.charToByteArray(charArray, charset, offset, length));
     }
 
     /**

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

@@ -21,11 +21,27 @@
 
 package at.favre.lib.bytes;
 
-import java.io.*;
+import java.io.ByteArrayOutputStream;
+import java.io.DataInput;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
+import java.nio.CharBuffer;
+import java.nio.charset.Charset;
 import java.nio.file.Files;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.Objects;
+import java.util.Random;
+import java.util.UUID;
 
 /**
  * Common Util methods to convert or modify byte arrays
@@ -373,6 +389,37 @@ static byte[] readFromFile(File file) {
         }
     }
 
+    /**
+     * Converts a char array to a byte array with given charset and range
+     *
+     * @param charArray to get the byte array from
+     * @param charset   charset to be used to decode the char array
+     * @param offset    to start reading the char array from (must be smaller than length and gt 0)
+     * @param length    from offset (must be between 0 and charArray.length)
+     * @return byte array of encoded chars
+     */
+    static byte[] charToByteArray(char[] charArray, Charset charset, int offset, int length) {
+        if (offset < 0 || offset > charArray.length)
+            throw new IllegalArgumentException("offset must be gt 0 and smaller than array length");
+        if (length < 0 || length > charArray.length)
+            throw new IllegalArgumentException("length must be at least 1 and less than array length");
+        if (offset + length > charArray.length)
+            throw new IllegalArgumentException("length + offset must be smaller than array length");
+
+        if (length == 0) return new byte[0];
+
+        CharBuffer charBuffer = CharBuffer.wrap(charArray);
+
+        if (offset != 0 || length != charBuffer.remaining()) {
+            charBuffer = charBuffer.subSequence(offset, offset + length);
+        }
+
+        ByteBuffer bb = charset.encode(charBuffer);
+        byte[] bytes = new byte[bb.remaining()];
+        bb.get(bytes);
+        return bytes;
+    }
+
     /**
      * Shows the length and a preview of max 8 bytes of the given byte
      *

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

@@ -294,6 +294,8 @@ public void fromCharArray() {
         assertArrayEquals(String.valueOf(s1.toCharArray()).getBytes(StandardCharsets.ISO_8859_1), Bytes.from(s1.toCharArray(), StandardCharsets.ISO_8859_1).array());
         assertArrayEquals(String.valueOf(s1.toCharArray()).getBytes(StandardCharsets.UTF_16), Bytes.from(s1.toCharArray(), StandardCharsets.UTF_16).array());
         assertArrayEquals(String.valueOf(s1.toCharArray()).getBytes(StandardCharsets.UTF_8), Bytes.from(s1.toCharArray(), StandardCharsets.UTF_8).array());
+        assertArrayEquals(String.valueOf(s1.substring(0, 1).toCharArray()).getBytes(StandardCharsets.UTF_8), Bytes.from(s1.toCharArray(), StandardCharsets.UTF_8, 0, 1).array());
+        assertArrayEquals(String.valueOf(s1.substring(3, 7).toCharArray()).getBytes(StandardCharsets.UTF_8), Bytes.from(s1.toCharArray(), StandardCharsets.UTF_8, 3, 4).array());
         assertArrayEquals(Bytes.empty().array(), Bytes.from(CharBuffer.allocate(0)).array());
     }
 

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

@@ -25,6 +25,8 @@
 import org.junit.Test;
 
 import java.math.BigInteger;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Random;
@@ -299,4 +301,50 @@ public void testRightShiftAgainstRefImpl() {
             }
         }
     }
+
+    @Test
+    public void testCharToByteArray() {
+        Charset[] charsets = new Charset[]{StandardCharsets.UTF_8, StandardCharsets.US_ASCII, StandardCharsets.UTF_16};
+        for (Charset charset : charsets) {
+            checkCharArrayToByteArray("".toCharArray(), charset);
+            checkCharArrayToByteArray("A".toCharArray(), charset);
+            checkCharArrayToByteArray("12".toCharArray(), charset);
+            checkCharArrayToByteArray("XYZ".toCharArray(), charset);
+            checkCharArrayToByteArray("abcdefg".toCharArray(), charset);
+            checkCharArrayToByteArray("71oh872gdl2dhp81g".toCharArray(), charset);
+
+        }
+
+        checkCharArrayToByteArray("யe2ாமறிந்தиют убSîne klâwenasd1".toCharArray(), StandardCharsets.UTF_8);
+    }
+
+    private void checkCharArrayToByteArray(char[] subject, Charset charset) {
+        for (int lenI = 1; lenI < subject.length + 1; lenI++) {
+            for (int offsetI = 0; offsetI < subject.length; offsetI++) {
+                if (offsetI + lenI > subject.length) break;
+                byte[] bytes = Util.charToByteArray(subject, charset, offsetI, lenI);
+                assertEquals(Bytes.wrap(bytes), Bytes.wrap(new String(subject).substring(offsetI, offsetI + lenI).getBytes(charset)));
+            }
+        }
+        compareArrayToByteArrayWithoutOffset(subject, charset);
+    }
+
+    private void compareArrayToByteArrayWithoutOffset(char[] subject, Charset charset) {
+        assertArrayEquals(Util.charToByteArray(subject, charset, 0, subject.length), new String(subject).getBytes(charset));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testCharToByteArrayIllegalOffset() {
+        Util.charToByteArray("abcdef".toCharArray(), StandardCharsets.UTF_8, -1, 1);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testCharToByteArrayIllegalLength() {
+        Util.charToByteArray("abcdef".toCharArray(), StandardCharsets.UTF_8, 0, -1);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testCharToByteArrayIllegalOffsetPlusLength() {
+        Util.charToByteArray("abcdef".toCharArray(), StandardCharsets.UTF_8, 4, 3);
+    }
 }