Copy namespaces into clj-commons

Update primitive-math to use clj-commons.primitive-math in new nses.

Author: skynet-gh

src/clj_commons/byte_streams.clj

@@ -0,0 +1,57 @@
+package clj_commons.byte_streams;
+
+import java.io.InputStream;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
+public class ByteBufferInputStream extends InputStream {
+
+    private ByteBuffer _buf;
+
+    public ByteBufferInputStream(ByteBuffer buf) {
+        _buf = buf;
+    }
+
+    public void close() {
+    }
+
+    public int available() {
+        return _buf.remaining();
+    }
+
+    public boolean markSupported() {
+        return true;
+    }
+
+    public void mark(int readlimit) {
+        _buf.mark();
+    }
+
+    public void reset() {
+        _buf.reset();
+    }
+
+    public long skip(long n) {
+        int nP = Math.min((int)n, _buf.remaining());
+        _buf.position(_buf.position() + nP);
+        return (long)nP;
+    }
+
+    public int read() throws IOException {
+        if (!_buf.hasRemaining()) {
+            return -1;
+        } else {
+            return (int) _buf.get() & 0xFF;
+        }
+    }
+
+    public int read(byte[] bytes, int offset, int length) throws IOException {
+        length = Math.min(length, _buf.remaining());
+        if (length == 0) {
+            return -1;
+        } else {
+            _buf.get(bytes, offset, length);
+            return length;
+        }
+    }
+}

src/clj_commons/byte_streams/ByteBufferInputStream.java

@@ -0,0 +1,52 @@
+package clj_commons.byte_streams;
+
+import java.io.IOException;
+
+public class InputStream extends java.io.InputStream {
+
+    public interface Streamable {
+        int available();
+        void close();
+        long skip(long n);
+        int read() throws IOException;
+        int read(byte[] bytes, int offset, int length) throws IOException;
+    }
+
+    private Streamable _s;
+
+    public InputStream(Streamable s) {
+        _s = s;
+    }
+
+    public void close() {
+        _s.close();
+    }
+
+    public int available() {
+        return _s.available();
+    }
+
+    public boolean markSupported() {
+        return false;
+    }
+
+    public void mark(int readlimit) {
+        throw new UnsupportedOperationException();
+    }
+
+    public void reset() {
+        throw new UnsupportedOperationException();
+    }
+
+    public long skip(long n) {
+        return _s.skip(n);
+    }
+
+    public int read() throws IOException {
+        return _s.read();
+    }
+
+    public int read(byte[] bytes, int offset, int length) throws IOException {
+        return _s.read(bytes, offset, length);
+    }
+}

src/clj_commons/byte_streams/InputStream.java

@@ -0,0 +1,7 @@
+package clj_commons.byte_streams;
+
+public class Utils {
+    public static byte[] byteArray(int length) {
+        return new byte[length];
+    }
+}

src/clj_commons/byte_streams/Utils.java

@@ -0,0 +1,122 @@
+(ns clj-commons.byte-streams.char-sequence
+  (:refer-clojure :exclude [flush])
+  (:import
+    [java.util.concurrent.locks
+     ReentrantLock]
+    [java.io
+     ByteArrayOutputStream]
+    [java.nio
+     ByteBuffer
+     CharBuffer]
+    [java.nio.charset
+     Charset
+     CharsetDecoder
+     CoderResult
+     CodingErrorAction]))
+
+(set! *unchecked-math* true)
+
+(defn coding-error-action [action]
+  (case
+    :report  CodingErrorAction/REPORT
+    :ignore  CodingErrorAction/IGNORE
+    :replace CodingErrorAction/REPLACE))
+
+(defn parse-result [^CoderResult result]
+  (cond
+    (.isUnderflow result) :underflow
+    (.isOverflow result) :overflow
+    :else (throw (IllegalArgumentException. "Malformed byte-stream input to CharsetDecoder"))))
+
+(defn decode
+  [^CharsetDecoder decoder ^ByteBuffer in ^CharBuffer out]
+  (parse-result (.decode decoder in out false)))
+
+(defn flush
+  [^CharsetDecoder decoder ^ByteBuffer in ^CharBuffer out]
+  (parse-result (.decode decoder (or in (ByteBuffer/allocate 0)) out true))
+  (parse-result (.flush decoder out)))
+
+(defn concat-bytes [^ByteBuffer a ^ByteBuffer b]
+  (let [buf (ByteBuffer/allocate (+ (.remaining a) (.remaining b)))]
+    (.put buf a)
+    (.put buf b)
+    (.flip buf)))
+
+(defn lazy-char-buffer-sequence
+  [^CharsetDecoder decoder
+   chunk-size
+   ^ByteBuffer extra-bytes
+   close-fn
+   byte-source]
+  (lazy-seq
+    (let [num-bytes (+ (long
+                         (if extra-bytes
+                           (.remaining extra-bytes)
+                           0))
+                      (long chunk-size))
+          len (long
+                (Math/ceil
+                  (/ num-bytes
+                    (.averageCharsPerByte decoder))))
+          out (CharBuffer/allocate len)]
+
+      (if (and extra-bytes (= :overflow (decode decoder extra-bytes out)))
+
+        ;; we didn't even exhaust the overflow bytes, try again
+        (cons
+          out
+          (lazy-char-buffer-sequence decoder chunk-size extra-bytes close-fn byte-source))
+
+        (if-let [in (byte-source chunk-size)]
+          (let [in (if (and extra-bytes (.hasRemaining extra-bytes))
+                     (concat-bytes extra-bytes in)
+                     in)
+                result (decode decoder in out)]
+            (cons
+              (.flip out)
+              (lazy-char-buffer-sequence
+                decoder
+                chunk-size
+                (when (.hasRemaining ^ByteBuffer in) in)
+                close-fn
+                byte-source)))
+          (do
+            (flush decoder extra-bytes out)
+            (when close-fn (close-fn))
+            (.flip out)))))))
+
+(defn decode-byte-source
+  [byte-source
+   close-fn
+   {:keys [chunk-size encoding on-encoding-error]
+    :or {chunk-size 1024
+         on-encoding-error :replace
+         encoding "UTF-8"}}]
+  (let [action (coding-error-action on-encoding-error)
+        decoder (doto (.newDecoder (Charset/forName encoding))
+                  (.onMalformedInput action)
+                  (.onUnmappableCharacter action))
+        s (lazy-char-buffer-sequence decoder chunk-size nil close-fn byte-source)]
+    (reify
+      java.io.Closeable
+      (close [_] (when close-fn (close-fn)))
+
+      CharSequence
+      (charAt [_ idx]
+        (loop [remaining idx, s s]
+          (if (empty? s)
+            (throw (IndexOutOfBoundsException. (str idx)))
+            (let [^CharBuffer buf (first s)]
+              (if (< (.remaining buf) remaining)
+                (.charAt buf remaining)
+                (recur (- remaining (.remaining buf)) (rest s)))))))
+      (length [_]
+        (reduce + (map #(.remaining ^CharBuffer %) s)))
+      #_(subSequence [_ start end]
+        )
+      (toString [_]
+        (let [buf (StringBuffer.)]
+          (doseq [b s]
+            (.append buf b))
+          (.toString buf))))))