Add hash feature

Author: patrickfav

CHANGELOG

@@ -3,6 +3,7 @@
 ## v0.4.1
 
 * add bitAt() utility
+* add hash feature
 
 ## v0.4.0
 

README.md

@@ -32,7 +32,7 @@ to blindly paste code snippets from
 It's main features include:
 
 * **Creation** from a wide variety of sources: multiple arrays, integers, streams, random, strings, files, ...
-* **Transformation** with many built-in: append, xor, and, or, shifts, shuffle, reverse, sort, ...
+* **Transformation** with many built-in: append, xor, and, hash, shifts, shuffle, reverse, sort, ...
 * **Validators** with the ability to arbitrarily combine multiple ones with logical expressions
 * **Parsing and Encoding** in most common binary-to-text-encodings: [hex](https://en.wikipedia.org/wiki/Hexadecimal), [base64](https://en.wikipedia.org/wiki/Base64), ...
 * **Immutable, Mutable and Read-Only** versions
@@ -194,6 +194,13 @@ Bytes copy = Bytes.wrap(array).copy(3, 17); //copy partial array
 Bytes resized = Bytes.wrap(array).resize(3); //from {3, 9, 2, 1} to {9, 2, 1}
 ```
 
+**Hashing** the internal byte array using the [`MessageDigest`](https://docs.oracle.com/javase/7/docs/api/java/security/MessageDigest.html) Java crypto API:
+
+```java
+Bytes hash = Bytes.wrap(array).sha256();
+Bytes hash = Bytes.wrap(array).hash("MD5");
+```
+
 Other transformers:
 
 ```java

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

@@ -782,6 +782,41 @@ public Bytes resize(int newByteLength) {
         return transform(new BytesTransformer.ResizeTransformer(newByteLength));
     }
 
+
+    /**
+     * Calculates sha256 on the underlying byte array and returns a byte instance containing the hash.
+     *
+     * @return sha256 (32 bytes) hash of internal byte array
+     * @throws IllegalArgumentException if the message digest algorithm can not be found in the security providers
+     * @see <a href="https://en.wikipedia.org/wiki/Secure_Hash_Algorithms">Secure Hash Algorithms</a>
+     */
+    public Bytes hashSha256() {
+        return hash(BytesTransformer.MessageDigestTransformer.ALGORITHM_SHA_256);
+    }
+
+    /**
+     * Calculates sha512 on the underlying byte array and returns a byte instance containing the hash.
+     *
+     * @return sha512 hash (64 bytes) of internal byte array
+     * @throws IllegalArgumentException if the message digest algorithm can not be found in the security providers
+     * @see <a href="https://en.wikipedia.org/wiki/Secure_Hash_Algorithms">Secure Hash Algorithms</a>
+     */
+    public Bytes hashSha512() {
+        return hash(BytesTransformer.MessageDigestTransformer.ALGORITHM_SHA_512);
+    }
+
+    /**
+     * Calculates hash with provided algorithm on the underlying byte array and returns a byte instance
+     * containing the hash.
+     *
+     * @param algorithm same format as passed to {@link java.security.MessageDigest#getInstance(String)}
+     * @return hash of internal byte array
+     * @throws IllegalArgumentException if the message digest algorithm can not be found in the security providers
+     */
+    public Bytes hash(String algorithm) {
+        return transform(new BytesTransformer.MessageDigestTransformer(algorithm));
+    }
+
     /**
      * Generic transformation of this instance.
      * <p>

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

@@ -22,6 +22,8 @@
 package at.favre.lib.bytes;
 
 import java.math.BigInteger;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
 import java.util.*;
 
 /**
@@ -314,4 +316,28 @@ public byte[] transform(byte[] currentArray, boolean inPlace) {
             return out;
         }
     }
+
+    /**
+     * Converts to hash
+     */
+    class MessageDigestTransformer implements BytesTransformer {
+        final static String ALGORITHM_SHA_256 = "SHA-256";
+        final static String ALGORITHM_SHA_512 = "SHA-512";
+
+        private final MessageDigest messageDigest;
+
+        MessageDigestTransformer(String digestName) {
+            try {
+                this.messageDigest = MessageDigest.getInstance(digestName);
+            } catch (NoSuchAlgorithmException e) {
+                throw new IllegalArgumentException("could not get message digest algorithm " + digestName, e);
+            }
+        }
+
+        @Override
+        public byte[] transform(byte[] currentArray, boolean inPlace) {
+            messageDigest.update(currentArray);
+            return messageDigest.digest();
+        }
+    }
 }

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

@@ -266,6 +266,12 @@ public void bitSwitchOutOfBounds() throws Exception {
         Bytes.from(4).switchBit(32, true);
     }
 
+    @Test
+    public void hash() throws Exception {
+        assertEquals(Bytes.parseHex("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"), Bytes.from("").hashSha256());
+        assertEquals(Bytes.parseHex("cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e"), Bytes.from("").hashSha512());
+    }
+
     @Test
     public void transform() throws Exception {
         assertArrayEquals(example_bytes_two, Bytes.from(example_bytes_two).transform(new BytesTransformer() {