Add gzip c

Author: patrickfav

CHANGELOG

@@ -5,6 +5,7 @@
 * add bitAt() utility
 * add hash feature
 * add checksum transformer
+* add gzip transformer
 
 ## v0.4.0
 

README.md

@@ -211,6 +211,15 @@ Bytes.wrap(array).transform(checksumCrc32());
 Bytes.wrap(array).transform(checksum(new Adler32(), ChecksumTransformer.Mode.TRANSFORM, 4));
 ```
 
+**GZip compression**:
+
+```java
+import static at.favre.lib.bytes.BytesTransformers.*;
+
+Bytes compressed = Bytes.wrap(array).transform(compressGzip());
+Bytes decompressed = compressed.transform(decompressGzip());
+```
+
 Other transformers:
 
 ```java

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

@@ -1,8 +1,12 @@
 package at.favre.lib.bytes;
 
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
 import java.util.Objects;
 import java.util.zip.CRC32;
 import java.util.zip.Checksum;
+import java.util.zip.GZIPInputStream;
+import java.util.zip.GZIPOutputStream;
 
 /**
  * Collection of additional {@link BytesTransformer} for more specific use cases
@@ -30,10 +34,6 @@ public static BytesTransformer checksumCrc32() {
         return new ChecksumTransformer(new CRC32(), ChecksumTransformer.Mode.TRANSFORM, 4);
     }
 
-    /**
-     * Create a {@link BytesTransformer} which transforms to 4 byte Crc32 checksum of given bytes
-     * @return transformer
-     */
     /**
      * Create a {@link BytesTransformer} which transforms to 4 byte Crc32 checksum of given bytes
      *
@@ -47,6 +47,28 @@ public static BytesTransformer checksum(Checksum checksum, ChecksumTransformer.M
         return new ChecksumTransformer(checksum, mode, checksumLengthByte);
     }
 
+    /**
+     * Create a {@link BytesTransformer} which gzip compresses the internal byte array
+     *
+     * @return transformer
+     * @throws IllegalStateException if compression was not possible (i.e. wrapped {@link java.io.IOException})
+     * @see <a href="https://en.wikipedia.org/wiki/Gzip">Gzip</a>
+     */
+    public static BytesTransformer compressGzip() {
+        return new GzipCompressor(true);
+    }
+
+    /**
+     * Create a {@link BytesTransformer} which gzip decompresses the internal byte array
+     *
+     * @return transformer
+     * @throws IllegalStateException if compression was not possible (i.e. wrapped {@link java.io.IOException})
+     * @see <a href="https://en.wikipedia.org/wiki/Gzip">Gzip</a>
+     */
+    public static BytesTransformer decompressGzip() {
+        return new GzipCompressor(false);
+    }
+
     /**
      * Adds or converts to arbitrary checksum
      */
@@ -67,7 +89,7 @@ enum Mode {
         private final int checksumLengthByte;
 
         public ChecksumTransformer(Checksum checksum, Mode mode, int checksumLengthByte) {
-            if (checksumLengthByte < 0 || checksumLengthByte > 8)
+            if (checksumLengthByte <= 0 || checksumLengthByte > 8)
                 throw new IllegalArgumentException("checksumlength must be between 1 and 8 bytes");
 
             Objects.requireNonNull(checksum, "checksum instance must not be null");
@@ -88,4 +110,58 @@ public byte[] transform(byte[] currentArray, boolean inPlace) {
             }
         }
     }
+
+    /**
+     * Byte compression with gzip
+     */
+    final static class GzipCompressor implements BytesTransformer {
+        private final boolean compress;
+
+        public GzipCompressor(boolean compress) {
+            this.compress = compress;
+        }
+
+        @Override
+        public byte[] transform(byte[] currentArray, boolean inPlace) {
+            return compress ? compress(currentArray) : decompress(currentArray);
+        }
+
+        private byte[] decompress(byte[] compressedContent) {
+            ByteArrayOutputStream bos = new ByteArrayOutputStream();
+            GZIPInputStream gzipInputStream = null;
+            byte[] returnBuffer;
+            try {
+                int len;
+                byte buffer[] = new byte[4 * 1024];
+                gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(compressedContent));
+
+                while ((len = gzipInputStream.read(buffer)) > 0) {
+                    bos.write(buffer, 0, len);
+                }
+
+                gzipInputStream.close();
+                returnBuffer = bos.toByteArray();
+                bos.close();
+                return returnBuffer;
+            } catch (Exception e) {
+                throw new IllegalStateException("could not decompress gzip", e);
+            }
+        }
+
+        private byte[] compress(byte[] content) {
+            ByteArrayOutputStream bos = new ByteArrayOutputStream(content.length);
+            GZIPOutputStream gzipOutputStream = null;
+            byte[] returnBuffer;
+            try {
+                gzipOutputStream = new GZIPOutputStream(bos);
+                gzipOutputStream.write(content);
+                gzipOutputStream.close();
+                returnBuffer = bos.toByteArray();
+                bos.close();
+                return returnBuffer;
+            } catch (Exception e) {
+                throw new IllegalStateException("could not compress gzip", e);
+            }
+        }
+    }
 }

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

@@ -27,7 +27,7 @@
 /**
  * Util and easy access for {@link BytesValidators}
  */
-public class BytesValidators {
+public final class BytesValidators {
 
     private BytesValidators() {
     }

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

@@ -273,7 +273,11 @@ public void bitSwitchOutOfBounds() throws Exception {
     @Test
     public void hash() throws Exception {
         assertEquals(Bytes.parseHex("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"), Bytes.from("").hashSha256());
+        assertEquals(Bytes.parseHex("e362eea626386c93a54c9b82e6b896c0350fbff0ee12f284660253aac0908cfb"), Bytes.from("ö9h%6Ghh1\"").hashSha256());
         assertEquals(Bytes.parseHex("cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e"), Bytes.from("").hashSha512());
+        assertEquals(Bytes.parseHex("106747C3DDC117091BEF8D21AEBAA8D314656D3AE1135AB36F4C0B07A264127CF625FE616751BEC66B43032B904E2D3B6C21BF14E078F6BB775A72503F48111D"), Bytes.from("ö9h%6Ghh1\"").hashSha512());
+        assertEquals(Bytes.parseHex("d41d8cd98f00b204e9800998ecf8427e"), Bytes.from("").hash("MD5"));
+        assertEquals(Bytes.parseHex("ff38205f1cb22f588d8bc9ae21f22092"), Bytes.from("ö9h%6Ghh1\"").hash("MD5"));
     }
 
     @Test
@@ -289,6 +293,32 @@ public void checksumTest() throws Exception {
                 Bytes.from(example2_bytes_seven).transform(checksum(new Adler32(), ChecksumTransformer.Mode.TRANSFORM, 4)));
     }
 
+    @Test(expected = IllegalArgumentException.class)
+    public void checksumTestIllegalByteLengthTooShort() throws Exception {
+        Bytes.from(example2_bytes_seven).transform(checksum(new CRC32(), ChecksumTransformer.Mode.TRANSFORM, 0));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void checksumTestIllegalByteLengthTooLong() throws Exception {
+        Bytes.from(example2_bytes_seven).transform(checksum(new CRC32(), ChecksumTransformer.Mode.TRANSFORM, 9));
+    }
+
+    @Test
+    public void testCompress() throws Exception {
+        for (int i = 1; i < 10; i++) {
+            testCompressInternal(256 * i);
+        }
+    }
+
+    private void testCompressInternal(int length) {
+        Bytes emptyArray = Bytes.allocate(length);
+        byte[] compressed = Bytes.from(emptyArray).transform(compressGzip()).array();
+        byte[] uncompressed = Bytes.wrap(compressed).transform(decompressGzip()).array();
+        assertArrayEquals(emptyArray.array(), uncompressed);
+        assertArrayNotEquals(compressed, uncompressed);
+        assertTrue("compressed is not smaller " + compressed.length + " vs " + uncompressed.length, compressed.length < uncompressed.length);
+    }
+
     @Test
     public void transform() throws Exception {
         assertArrayEquals(example_bytes_two, Bytes.from(example_bytes_two).transform(new BytesTransformer() {