added crc64, md5, sha1, sha256

Author: source-c

profiles.clj

@@ -1,14 +1,19 @@
-{:dev     {:global-vars    {*warn-on-reflection* true}
+{:dev      {:global-vars       {*warn-on-reflection* true}
 
-           :source-paths   #{"src"}
-           :resource-paths ["resources"]
+            :source-paths      #{"src-clj"}
+            :java-source-paths #{"src-java"}
+            :resource-paths    ["resources"]
 
-           :target-path    "target/%s"
-           :clean-targets  ^{:protect false} [:target-path]
+            :jar-exclusions    [#"\.java"]
 
-           :plugins        [[org.apache.maven.wagon/wagon-ssh-external "3.4.3"]
-                            [org.apache.maven.wagon/wagon-http-lightweight "3.4.3"]]}
+            :target-path       "target/%s"
+            :clean-targets     ^{:protect false} [:target-path]
+
+            :dependencies      [[commons-codec "1.15"]]
+
+            :plugins           [[org.apache.maven.wagon/wagon-ssh-external "3.4.3"]
+                                [org.apache.maven.wagon/wagon-http-lightweight "3.4.3"]]}
 
  :provided {:dependencies [[org.clojure/clojure "1.10.3"]]}
 
- :jar     {:aot :all}}
+ :jar      {:aot :all}}

src-clj/zlib_tiny/core.clj

@@ -0,0 +1,115 @@
+(ns zlib-tiny.core
+  (:import (java.util.zip InflaterInputStream
+                          GZIPInputStream
+                          GZIPOutputStream
+                          DeflaterInputStream
+                          Inflater
+                          ZipException
+                          CRC32)
+           (zlib_tiny CRC64)
+           (org.apache.commons.io IOUtils)
+           (java.security MessageDigest)
+           (java.io ByteArrayInputStream
+                    ByteArrayOutputStream
+                    BufferedInputStream
+                    InputStream)))
+
+(defn str->bytes
+  "Returns the encoding's bytes corresponding to the given string. If no
+  encoding is specified, UTF-8 is used."
+  [^String s & [^String encoding]]
+  (.getBytes s (or encoding "UTF-8")))
+
+(defn bytes->str
+  "Returns the String corresponding to the given encoding's decoding of the
+  given bytes. If no encoding is specified, UTF-8 is used."
+  [^bytes b & [^String encoding]]
+  (String. b (or encoding "UTF-8")))
+
+(defn gunzip
+  "Returns a gunzip'd version of the given byte array."
+  [b]
+  (when b
+    (cond
+      (instance? InputStream b)
+      (GZIPInputStream. b)
+      :else
+      (IOUtils/toByteArray (GZIPInputStream. (ByteArrayInputStream. b))))))
+
+(defn gzip
+  "Returns a gzip'd version of the given byte array."
+  [b]
+  (when b
+    (let [baos (ByteArrayOutputStream.)
+          gos (GZIPOutputStream. baos)]
+      (IOUtils/copy (ByteArrayInputStream. b) gos)
+      (.close gos)
+      (.toByteArray baos))))
+
+(defn force-byte-array
+  "force b as byte array if it is an InputStream, also close the stream"
+  ^bytes [b]
+  (if (instance? InputStream b)
+    (try (IOUtils/toByteArray ^InputStream b)
+         (finally (.close ^InputStream b)))
+    b))
+
+(defn inflate
+  "Returns a zlib inflate'd version of the given byte array or InputStream."
+  [b]
+  (when b
+    ;; This weirdness is because we don't know about what kind of deflation
+    ;; sender using, so we try one way, then if that doesn't work, reset and
+    ;; try the other way
+    (let [stream (BufferedInputStream. (if (instance? InputStream b)
+                                         b
+                                         (ByteArrayInputStream. b)))
+          _ (.mark stream 512)
+          iis (InflaterInputStream. stream)
+          readable? (try (.read iis) true
+                         (catch ZipException _ false))]
+      (.reset stream)
+      (if readable?
+        (InflaterInputStream. stream)
+        (InflaterInputStream. stream (Inflater. true))))))
+
+(defn deflate
+  "Returns a deflate'd version of the given byte array."
+  [b]
+  (when b
+    (IOUtils/toByteArray (DeflaterInputStream. (ByteArrayInputStream. b)))))
+
+(comment "ZLib Example"
+         (bytes->str (force-byte-array (inflate (deflate (str->bytes "test it!"))))))
+(comment "GZip Example"
+         (bytes->str (gunzip (gzip (str->bytes "test it!")))))
+
+(defn crc32
+  ^Long [^bytes b]
+  (let [o (CRC32.)]
+    (.update o b)
+    (.getValue o)))
+
+(defn crc64
+  ^Long [^bytes b]
+  (let [o (CRC64.)]
+    (.update o b)
+    (.getValue o)))
+
+(defn md5
+  ^bytes [^bytes b]
+  (let [o (MessageDigest/getInstance "md5")]
+    (.update o b)
+    (.digest o)))
+
+(defn sha-1
+  ^bytes [^bytes b]
+  (let [o (MessageDigest/getInstance "sha1")]
+    (.update o b)
+    (.digest o)))
+
+(defn sha-256
+  ^bytes [^bytes b]
+  (let [o (MessageDigest/getInstance "sha256")]
+    (.update o b)
+    (.digest o)))

src-java/CRC64.java

@@ -0,0 +1,45 @@
+package zlib_tiny;
+
+public class CRC64 {
+
+    private static final long poly = 0xC96C5795D7870F42L;
+    private static final long[] crcTable = new long[256];
+
+    private long crc = -1;
+
+    static {
+        for (int b = 0; b < crcTable.length; ++b) {
+            long r = b;
+            for (int i = 0; i < 8; ++i) {
+                if ((r & 1) == 1)
+                    r = (r >>> 1) ^ poly;
+                else
+                    r >>>= 1;
+            }
+
+            crcTable[b] = r;
+        }
+    }
+
+    public CRC64() {
+    }
+
+    public void update(byte b) {
+        crc = crcTable[(b ^ (int) crc) & 0xFF] ^ (crc >>> 8);
+    }
+
+    public void update(byte[] buf) {
+        update(buf, 0, buf.length);
+    }
+
+    public void update(byte[] buf, int off, int len) {
+        int end = off + len;
+
+        while (off < end)
+            crc = crcTable[(buf[off++] ^ (int) crc) & 0xFF] ^ (crc >>> 8);
+    }
+
+    public long getValue() {
+        return ~crc;
+    }
+}