Add nullsafe wrap method

Author: patrickfav

CHANGELOG

@@ -1,5 +1,9 @@
 # Releases
 
+## v0.4.5
+
+* add nullSafe wrapper
+
 ## v0.4.4
 
 * add feature for gathering parts of the array as primitives (e.g. intAt(int position))

README.md

@@ -108,6 +108,12 @@ Bytes.wrap(myArray).copy() ~ Bytes.from(myArray)
 
 #### More Constructors
 
+For a **null-safe version**, which uses the empty array in case of a null byte array:
+
+```java
+Bytes.wrapNullSafe(null);
+```
+
 **Concatenating** of multiple byte arrays or bytes:
 
 ```java

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

@@ -97,6 +97,22 @@ public static Bytes wrap(Bytes bytes) {
         return new Bytes(bytes.internalArray(), bytes.byteOrder);
     }
 
+    /**
+     * Creates a new instance with given byte array.
+     * <p>
+     * The new instance will be backed by the given byte array;
+     * that is, modifications to the bytes will cause the array to be modified
+     * and vice versa.
+     * <p>
+     * If given array is null, a zero length byte array will be created and used instead.
+     *
+     * @param array to use directly or zero length byte array
+     * @return new instance
+     */
+    public static Bytes wrapNullSafe(byte[] array) {
+        return wrap(array != null ? array : new byte[0], ByteOrder.BIG_ENDIAN);
+    }
+
     /**
      * Creates a new instance with given byte array.
      * <p>
@@ -1000,7 +1016,7 @@ public int unsignedByteAt(int index) {
      */
     public char charAt(int index) {
         Util.checkIndexBounds(length(), index, 2, "char");
-        return ((ByteBuffer) ByteBuffer.wrap(internalArray()).order(byteOrder).position(index)).getChar();
+        return ByteBuffer.wrap(internalArray()).order(byteOrder).position(index).getChar();
     }
 
     /**
@@ -1013,7 +1029,7 @@ public char charAt(int index) {
      */
     public short shortAt(int index) {
         Util.checkIndexBounds(length(), index, 2, "short");
-        return ((ByteBuffer) ByteBuffer.wrap(internalArray()).order(byteOrder).position(index)).getShort();
+        return ByteBuffer.wrap(internalArray()).order(byteOrder).position(index).getShort();
     }
 
     /**
@@ -1026,7 +1042,7 @@ public short shortAt(int index) {
      */
     public int intAt(int index) {
         Util.checkIndexBounds(length(), index, 4, "int");
-        return ((ByteBuffer) ByteBuffer.wrap(internalArray()).order(byteOrder).position(index)).getInt();
+        return ByteBuffer.wrap(internalArray()).order(byteOrder).position(index).getInt();
     }
 
     /**
@@ -1039,7 +1055,7 @@ public int intAt(int index) {
      */
     public long longAt(int index) {
         Util.checkIndexBounds(length(), index, 8, "long");
-        return ((ByteBuffer) ByteBuffer.wrap(internalArray()).order(byteOrder).position(index)).getLong();
+        return ByteBuffer.wrap(internalArray()).order(byteOrder).position(index).getLong();
     }
 
     /**

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

@@ -120,7 +120,9 @@ public MutableBytes secureWipe() {
      */
     public MutableBytes secureWipe(SecureRandom random) {
         Objects.requireNonNull(random, "must non-null random");
-        random.nextBytes(internalArray());
+        if (length() > 0) {
+            random.nextBytes(internalArray());
+        }
         return this;
     }
 

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

@@ -57,6 +57,22 @@ public void wrapTest() throws Exception {
 
         Bytes b2 = Bytes.wrap(b);
         assertSame(b.array(), b2.array());
+
+        Bytes bNullSafe = Bytes.wrapNullSafe(example_bytes_seven);
+        assertSame(example_bytes_seven, bNullSafe.array());
+
+        Bytes bNullSafe1 = Bytes.wrapNullSafe(null);
+        assertEquals(0, bNullSafe1.length());
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void wrapTestNullExpected() throws Exception {
+        Bytes.wrap((byte[]) null);
+    }
+
+    @Test
+    public void wrapTestNullSafe() throws Exception {
+        Bytes.wrapNullSafe(null);
     }
 
     @Test