Adapt references specs to work with cljs.

Among with some codestyle fixes and function naming consistency
improvements.

Author: niwinz

src/octet/core.cljc

@@ -42,8 +42,8 @@
 (util/defalias string string-spec/string)
 (util/defalias string* string-spec/string*)
 (util/defalias vector* coll-spec/vector*)
-(util/defalias ref-string* ref-spec/ref-string*)
-(util/defalias ref-bytes* ref-spec/ref-bytes*)
+(util/defalias ref-string ref-spec/ref-string)
+(util/defalias ref-bytes ref-spec/ref-bytes)
 (util/defalias int16 basic-spec/int16)
 (util/defalias uint16 basic-spec/uint16)
 (util/defalias int32 basic-spec/int32)

src/octet/spec.cljc

@@ -41,6 +41,12 @@
   (read [_ buff start] "Read all data from buffer.")
   (write [_ buff start data] "Read all data from buffer."))
 
+(defprotocol ISpecWithRef
+  "Abstraction to support specs having references to other
+   specs within an AssociativeSpec or an IndexedSpec"
+  (read* [_ buff start data] "Read data from buffer, use data to calculate length etc")
+  (write* [_ buff start value types data] "Write data from buffer, use data to store length etc"))
+
 (defprotocol ISpecSize
   "Abstraction for calculate size of static specs."
   (size [_] "Calculate the size in bytes of the object."))
@@ -49,12 +55,6 @@
   "Abstraction for calculate size for dynamic specs."
   (size* [_ data] "Calculate the size in bytes of the object having a data."))
 
-(defprotocol ISpecWithRef
-  "Abstraction to support specs having references to other
-   specs within an AssociativeSpec or an IndexedSpec"
-  (read* [_ buff start data] "Read data from buffer, use data to calculate length etc")
-  (write* [_ buff start value types data] "Write data from buffer, use data to store length etc"))
-
 ;; --- Composed Spec Types
 
 (deftype AssociativeSpec [data dict types]

src/octet/spec/basic.cljc

@@ -27,9 +27,7 @@
   (:require [octet.buffer :as buffer]
             [octet.spec :as spec]))
 
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Types implementation
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; --- Types implementation
 
 (defn primitive-spec
   [size readfn writefn]
@@ -115,9 +113,7 @@
       (buffer/write-bytes buff pos size value)
       size)))
 
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Unsigned Primitives
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; --- Unsigned Primitives
 
 (def ^{:doc "Unsinged int16 type spec."}
   uint16 (primitive-spec 2 buffer/read-ushort buffer/write-ushort))

src/octet/spec/reference.cljc

@@ -1,4 +1,4 @@
-;; Copyright (c) 2015-2016 Andrey Antukh <niwi@niwi.nz>
+;; Copyright (c) 2015-2018 Andrey Antukh <niwi@niwi.nz>
 ;; All rights reserved.
 ;;
 ;; Redistribution and use in source and binary forms, with or without
@@ -23,72 +23,121 @@
 ;; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 (ns octet.spec.reference
+  "Spec types for arbitrary length byte arrays/strings with a length reference."
   (:require [octet.buffer :as buffer]
             [octet.spec :as spec]
+            [octet.spec.basic :as basic-spec]
             [octet.spec.string :as string-spec]))
 
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Spec types for arbitrary length byte arrays/strings with a length reference
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(defn- ref-size [type data]
-  (if (satisfies? spec/ISpecSize type)
-    (.size type)
-    (.size* type data)))
+(defn- ref-size
+  [type data]
+  (cond
+    (satisfies? spec/ISpecDynamicSize type)
+    (spec/size* type data)
 
-(defn- coerce-types [types]
+    (satisfies? spec/ISpecSize type)
+    (spec/size type)
+
+    :else
+    (throw (ex-info "Unexpected type" {:type type}))))
+
+(defn- coerce-types
   "to make it terser to handle both maps (assoc spec) and seq/vector
   (indexed spec), we coerce the seq/vector types to maps where the
   keys are indexes"
-  (cond (map? types) types
-        (or (seq? types)
-            (vector? types)) (apply array-map (interleave (range) types))
-        :else (throw (ex-info "invalid type structure, not map, seq or vector"
-                              {:type-structure types}))))
-
-(defn- ref-len-offset [ref-kw-or-index types data]
-  "for ref-xxxx* specs, calculate the byte offset of the
+  [types]
+  (cond
+    (map? types)
+    types
+
+    (or (seq? types)
+        (vector? types))
+    (apply array-map (interleave (range) types))
+
+    :else (throw (ex-info "invalid type structure, not map, seq or vector"
+                          {:type-structure types}))))
+
+(defn- ref-len-offset
+  "for ref-xxxx specs, calculate the byte offset of the
   spec containing the length, i.e. (spec :a (int16) :b (int16) c: (ref-string* :b))
   would cause this method to be called with :b (since the ref-string has a :b
   reference as its length) and should then return 2 as the second int16 is at byte offset 2"
+  [ref-kw-or-index types data]
   (reduce-kv
-    (fn [acc kw-or-index type]
-      (if (= ref-kw-or-index kw-or-index)
-        (reduced acc)
-        (+ acc (ref-size type (get data kw-or-index)))))
-    0
-    types))
-
-(defn- ref-write* [ref-kw-or-index buff pos value types data]
+   (fn [acc kw-or-index type]
+     (if (= ref-kw-or-index kw-or-index)
+       (reduced acc)
+       (+ acc (ref-size type (get data kw-or-index)))))
+   0
+   types))
+
+(defn- ref-write-length
+  [type buff offset length]
+  (cond
+    (identical? basic-spec/int16 type)
+    (buffer/write-short buff offset length)
+
+    (identical? basic-spec/int32 type)
+    (buffer/write-int buff offset length)
+
+    (identical? basic-spec/int64 type)
+    (buffer/write-long buff offset length)
+
+    (identical? basic-spec/int64 type)
+    (buffer/write-long buff offset length)
+
+    (identical? basic-spec/uint16 type)
+    (buffer/write-ushort buff offset length)
+
+    (identical? basic-spec/uint32 type)
+    (buffer/write-uint buff offset length)
+
+    (identical? basic-spec/uint64 type)
+    (buffer/write-ulong buff offset length)
+
+    :else
+    (throw (ex-info "Invalid reference type: should be int16, int32, int64 and unsigned variants" {}))))
+
+(defn- ref-write
   "write a ref spec, will also write the length to the length spec"
+  [ref-kw-or-index buff pos value types data]
   (let [input      (if (string? value) (string-spec/string->bytes value) value)
         length     (count input)
         types      (coerce-types types)
         len-offset (ref-len-offset ref-kw-or-index types data)
         len-type   (get types ref-kw-or-index)]
-    (.write len-type buff len-offset length)
+    (ref-write-length len-type buff len-offset length)
     (buffer/write-bytes buff pos length input)
     (+ length)))
 
-(defn- ref-read* [ref-kw-or-index buff pos parent]
+(defn- ref-read
   "read ref spec, will read the length from the length spec"
-  (let [datasize (cond (map? parent) (ref-kw-or-index parent)
-                       (or (seq? parent) (vector? parent)) (get parent ref-kw-or-index)
-                       :else (throw (ex-info
-                                      (str "bad ref-string*/ref-bytes* length reference  - " ref-kw-or-index)
-                                      {:length-kw ref-kw-or-index
-                                       :data-read parent})))
+  [ref-kw-or-index buff pos parent]
+  (let [datasize (cond
+                   (map? parent)
+                   (ref-kw-or-index parent)
+
+                   (or (seq? parent) (vector? parent))
+                   (get parent ref-kw-or-index)
+
+                   :else
+                   (throw (ex-info
+                           (str "bad ref-string/ref-bytes length reference  - " ref-kw-or-index)
+                           {:length-kw ref-kw-or-index
+                            :data-read parent})))
+        ;; _ (println "FOFOFO:" parent ref-kw-or-index)
         data     (buffer/read-bytes buff pos datasize)]
     [datasize data]))
 
-(defn ref-bytes*
-  [ref-kw-or-index]
+(defn ref-bytes
   "create a dynamic length byte array where the length of the byte array is stored in another
   spec within the containing indexed spec or associative spec. Example usages:
   (spec (int16) (int16) (ref-bytes* 1))
   (spec :a (int16) :b (int32) (ref-bytes* :b))
   where the first example would store the length of the byte array in the second int16 and
   the second example would store the length of the byte array in the int32 at key :b."
+  [ref-kw-or-index]
   (reify
     #?@(:clj
         [clojure.lang.IFn
@@ -103,12 +152,12 @@
 
     spec/ISpecWithRef
     (read* [_ buff pos parent]
-      (ref-read* ref-kw-or-index buff pos parent))
+      (ref-read ref-kw-or-index buff pos parent))
 
     (write* [_ buff pos value types data]
-      (ref-write* ref-kw-or-index buff pos value types data))))
+      (ref-write ref-kw-or-index buff pos value types data))))
 
-(defn ref-string*
+(defn ref-string
   "create a dynamic length string  where the length of the string is stored in another
   spec within the containing indexed spec or associative spec. Example usages:
   (spec (int16) (int16) (ref-string* 1))
@@ -131,13 +180,8 @@
 
     spec/ISpecWithRef
     (read* [_ buff pos parent]
-      (let [[datasize bytes] (ref-read* ref-kw-or-index buff pos parent)]
+      (let [[datasize bytes] (ref-read ref-kw-or-index buff pos parent)]
         [datasize (string-spec/bytes->string bytes datasize)]))
 
     (write* [_ buff pos value types data]
-      (ref-write* ref-kw-or-index buff pos value types data))))
-
-(defn ref-vector*
-  [ref-kw-or-index]
-  ;; TODO: implement this
-  )
+      (ref-write ref-kw-or-index buff pos value types data))))