Merge pull request #64 from valerauko/develop/boxed-math

Resolve boxed math warnings

Author: KingMob

project.clj

@@ -13,7 +13,9 @@
   :profiles {:dev {:dependencies [[org.clojure/clojure "1.11.1"]
                                   [org.clojure/test.check "1.1.1"]
                                   [rhizome "0.2.9"]
-                                  [criterium "0.4.6"]]}
+                                  [criterium "0.4.6"]]
+                   :global-vars {*warn-on-reflection* true
+                                 *unchecked-math* :warn-on-boxed}}
              :ci {:dependencies [[org.clojure/clojure "1.11.1"]
                                  [org.clojure/test.check "1.1.1"]]}}
   :test-selectors {:stress :stress

src/byte_streams/graph.clj

@@ -9,7 +9,8 @@
    [manifold.stream :as s]
    [byte-streams
     [utils :refer [defprotocol+ defrecord+ deftype+]]
-    [protocols :as p]])
+    [protocols :as proto]]
+   [clj-commons.primitive-math :as p])
   (:import
    [java.util
     LinkedList
@@ -25,7 +26,7 @@
            (identical? f (.f ^Conversion x))
            (== cost (.cost ^Conversion x))))
   (hashCode [_]
-            (bit-xor (System/identityHashCode f) (unchecked-int cost))))
+            (p/bit-xor (System/identityHashCode f) (unchecked-int cost))))
 
 (deftype+ Type [wrapper type]
   Object
@@ -35,7 +36,7 @@
            (= wrapper (.wrapper ^Type x))
            (= type (.type ^Type x))))
   (hashCode [_]
-            (bit-xor
+            (p/bit-xor
              (hash wrapper)
              (hash type)))
   (toString [this]
@@ -131,7 +132,7 @@
                                      (assoc-in [(Type. 'seq src) (Type. 'seq dst)]
                                                (Conversion. (fn [x options] (map #(f % options) x)) cost))
                                      (assoc-in [(Type. 'stream src) (Type. 'stream dst)]
-                                               (Conversion. (fn [x options] (s/map #(f % options) x)) (+ cost 0.1)))))
+                                               (Conversion. (fn [x options] (s/map #(f % options) x)) (p/+ ^double cost 0.1)))))
                                m')]
                       (ConversionGraph. m')))
   (possible-sources [_]
@@ -160,7 +161,7 @@
 
 ;;;
 
-(defrecord+ ConversionPath [path fns visited? cost]
+(defrecord+ ConversionPath [path fns visited? ^double cost]
   Comparable
   (compareTo [_ x]
              (let [cmp (compare cost (.cost ^ConversionPath x))]
@@ -173,7 +174,7 @@
    (conj (.path p) [src dst])
    (conj (.fns p) (.f c))
    (conj (.visited? p) dst)
-   (+ (.cost p) (.cost c))))
+   (p/+ (.cost p) (.cost c))))
 
 (def conversion-path
   (memoize
@@ -242,11 +243,11 @@
       0 (fn [x _] x)
 
       1 (let [f (->> path :fns first)]
-          (if (p/closeable? src)
+          (if (proto/closeable? src)
             (fn [x options]
               (let [x' (f x options)]
-                (when-not (p/closeable? x')
-                  (p/close x))
+                (when-not (proto/closeable? x')
+                  (proto/close x))
                 x'))
             f))
 
@@ -258,12 +259,12 @@
                         (fn [x f]
 
                            ;; keep track of everything that needs to be closed once the bytes are exhausted
-                          (when (p/closeable? x)
-                            (.add close-fns #(p/close x)))
+                          (when (proto/closeable? x)
+                            (.add close-fns #(proto/close x)))
                           (f x options))
                         x
                         fns)]
-            (if-let [close-fn (when-not (or (p/closeable? result)
+            (if-let [close-fn (when-not (or (proto/closeable? result)
                                             (.isEmpty close-fns))
                                 #(loop []
                                    (when-let [f (.poll close-fns)]
@@ -284,7 +285,7 @@
                   ;; we assume that if the end-result is closeable, it will take care of all the intermediate
                   ;; objects beneath it.  I think this is true as long as we're not doing multiple streaming
                   ;; reads, but this might need to be revisited.
-                  (when-not (p/closeable? result)
+                  (when-not (proto/closeable? result)
                     (close-fn))
                   result))
               result)))))))

src/clj_commons/byte_streams.clj

@@ -429,15 +429,15 @@
 
 ;; byte-buffer => sequence of byte-buffers
 (def-conversion ^{:cost 0} [ByteBuffer (vector-of ByteBuffer)]
-  [buf {:keys [chunk-size]}]
+  [buf {:keys [^long chunk-size]}]
   (if chunk-size
     (let [lim (.limit buf)
           indices (range (.position buf) lim chunk-size)]
       (mapv
        #(-> buf
             .duplicate
             ^ByteBuffer (.position (int %))
-            ^ByteBuffer (.limit (int (min lim (+ (int %) chunk-size))))
+            ^ByteBuffer (.limit (int (min lim (p/+ (int %) chunk-size))))
             .slice)
        indices))
     [buf]))
@@ -587,7 +587,7 @@
 ;;
 (def-conversion ^{:cost 0
                   :doc "Assumes the file size is static."} [File (seq-of ByteBuffer)]
-  [file {:keys [chunk-size writable?] :or {chunk-size (int 2e9), writable? false}}]
+  [file {:keys [^long chunk-size writable?] :or {chunk-size (int 2e9), writable? false}}]
   (let [option-array (into-array StandardOpenOption
                                  (cond-> [StandardOpenOption/READ]
                                    writable?
@@ -597,7 +597,7 @@
                             (.toPath)
                             (FileChannel/open option-array))
         close-fn #(.close fc)
-        buf-seq (fn buf-seq [offset]
+        buf-seq (fn buf-seq [^long offset]
                   (when (and (.isOpen fc)
                              (> (.size fc) offset))
                     (let [remaining (- (.size fc) offset)
@@ -732,7 +732,7 @@
         (.flip buf))))
 
   ByteBuffer
-  (take-bytes! [this n _]
+  (take-bytes! [this ^long n _]
     (when (pos? (.remaining this))
       (let [n (int (min (.remaining this) n))
             buf (-> this
@@ -853,7 +853,7 @@
 
 (defn ^String to-string
   "Converts the object to a string.
-  Will consume all input it can. 
+  Will consume all input it can.
   Consider using to-reader, to-line-seq, or to-char-sequence for lazy / partial input consumption."
   ([x]
    (to-string x nil))

src/clj_commons/byte_streams/graph.clj

@@ -4,7 +4,8 @@
    [manifold.stream :as s]
    [clj-commons.byte-streams
     [utils :refer [defprotocol+ defrecord+ deftype+]]
-    [protocols :as p]])
+    [protocols :as proto]]
+   [clj-commons.primitive-math :as p])
   (:import
    [java.util
     LinkedList
@@ -20,7 +21,7 @@
            (identical? f (.f ^Conversion x))
            (== cost (.cost ^Conversion x))))
   (hashCode [_]
-            (bit-xor (System/identityHashCode f) (unchecked-int cost))))
+            (p/bit-xor (System/identityHashCode f) (unchecked-int cost))))
 
 (deftype+ Type [wrapper type]
   Object
@@ -30,7 +31,7 @@
            (= wrapper (.wrapper ^Type x))
            (= type (.type ^Type x))))
   (hashCode [_]
-            (bit-xor
+            (p/bit-xor
              (hash wrapper)
              (hash type)))
   (toString [this]
@@ -126,7 +127,7 @@
                                      (assoc-in [(Type. 'seq src) (Type. 'seq dst)]
                                                (Conversion. (fn [x options] (map #(f % options) x)) cost))
                                      (assoc-in [(Type. 'stream src) (Type. 'stream dst)]
-                                               (Conversion. (fn [x options] (s/map #(f % options) x)) (+ cost 0.1)))))
+                                               (Conversion. (fn [x options] (s/map #(f % options) x)) (p/+ ^double cost 0.1)))))
                                m')]
                       (ConversionGraph. m')))
   (possible-sources [_]
@@ -155,7 +156,7 @@
 
 ;;;
 
-(defrecord+ ConversionPath [path fns visited? cost]
+(defrecord+ ConversionPath [path fns visited? ^double cost]
   Comparable
   (compareTo [_ x]
              (let [cmp (compare cost (.cost ^ConversionPath x))]
@@ -234,11 +235,11 @@
       0 (fn [x _] x)
 
       1 (let [f (->> path :fns first)]
-          (if (p/closeable? src)
+          (if (proto/closeable? src)
             (fn [x options]
               (let [x' (f x options)]
-                (when-not (p/closeable? x')
-                  (p/close x))
+                (when-not (proto/closeable? x')
+                  (proto/close x))
                 x'))
             f))
 
@@ -250,12 +251,12 @@
                         (fn [x f]
 
                            ;; keep track of everything that needs to be closed once the bytes are exhausted
-                          (when (p/closeable? x)
-                            (.add close-fns #(p/close x)))
+                          (when (proto/closeable? x)
+                            (.add close-fns #(proto/close x)))
                           (f x options))
                         x
                         fns)]
-            (if-let [close-fn (when-not (or (p/closeable? result)
+            (if-let [close-fn (when-not (or (proto/closeable? result)
                                             (.isEmpty close-fns))
                                 #(loop []
                                    (when-let [f (.poll close-fns)]
@@ -276,7 +277,7 @@
                   ;; we assume that if the end-result is closeable, it will take care of all the intermediate
                   ;; objects beneath it.  I think this is true as long as we're not doing multiple streaming
                   ;; reads, but this might need to be revisited.
-                  (when-not (p/closeable? result)
+                  (when-not (proto/closeable? result)
                     (close-fn))
                   result))
               result)))))))