132 lines
3.7 KiB
Clojure
132 lines
3.7 KiB
Clojure
(ns bytechannel-and-related-classes
|
|
(:import (java.io InputStream OutputStream)
|
|
(java.nio ByteBuffer)
|
|
(java.nio.channels ByteChannel
|
|
Channels)))
|
|
|
|
;;
|
|
;; Accept a ByteChannel and return an InputStream that reads data from
|
|
;; the given ByteChannel. Buffer data in internal ByteBuffer.
|
|
;;
|
|
|
|
|
|
(defn channel->input-stream ^InputStream [^ByteChannel ch]
|
|
(let [buffer (doto (ByteBuffer/allocate 1024)
|
|
(.flip))
|
|
eof? (fn []
|
|
(if (.hasRemaining buffer)
|
|
;; Buffer has data that can be read:
|
|
false
|
|
;; Buffer is empty, try fill buffer from channel:
|
|
(do (.clear buffer)
|
|
(if (= (.read ch buffer) -1)
|
|
;; Channel is also empty
|
|
true
|
|
;; Successfully read data into buffer:
|
|
(do (.flip buffer)
|
|
false)))))]
|
|
(proxy [InputStream] []
|
|
(read
|
|
([]
|
|
(if (eof?)
|
|
-1
|
|
(-> (.get buffer)
|
|
(bit-and 0xff))))
|
|
([b]
|
|
(.read this b 0 (alength b)))
|
|
([b off len]
|
|
(if (eof?)
|
|
-1
|
|
(let [len (min (alength b)
|
|
(.remaining buffer))]
|
|
(.get buffer b 0 len)
|
|
len))))
|
|
(close []
|
|
(.close ch)))))
|
|
|
|
|
|
;;
|
|
;; Accept a ByteChannel and return an OutputStream that writes into the
|
|
;; channel
|
|
;;
|
|
|
|
|
|
(defn channel->output-stream ^OutputStream [^ByteChannel ch]
|
|
(proxy [OutputStream] []
|
|
(write
|
|
([v]
|
|
(if (bytes? v)
|
|
(.write ch (ByteBuffer/wrap v))
|
|
(let [buffer (ByteBuffer/allocate 1)]
|
|
(.put buffer (-> (Integer. v) (.byteValue)))
|
|
(.flip buffer)
|
|
(.write ch buffer))))
|
|
([v off len]
|
|
(.write ch (ByteBuffer/wrap v off len))))
|
|
(close []
|
|
(.close ch))))
|
|
|
|
|
|
;;
|
|
;; Tests:
|
|
;;
|
|
|
|
|
|
(defn read-byte-by-byte-test []
|
|
(let [in (-> (.getBytes "Hello")
|
|
(java.io.ByteArrayInputStream.)
|
|
(Channels/newChannel)
|
|
(channel->input-stream))]
|
|
(and (= (.read in) (int \H))
|
|
(= (.read in) (int \e))
|
|
(= (.read in) (int \l))
|
|
(= (.read in) (int \l))
|
|
(= (.read in) (int \o))
|
|
(= (.read in) -1))))
|
|
|
|
(defn read-byte-array []
|
|
(let [in (-> (.getBytes "Hello")
|
|
(java.io.ByteArrayInputStream.)
|
|
(Channels/newChannel)
|
|
(channel->input-stream))
|
|
buffer (byte-array 10)
|
|
len (.read in buffer)]
|
|
(and (= len 5)
|
|
(= (String. buffer 0 len) "Hello"))))
|
|
|
|
(defn read-all []
|
|
(let [in (-> (.getBytes "Hello")
|
|
(java.io.ByteArrayInputStream.)
|
|
(Channels/newChannel)
|
|
(channel->input-stream))
|
|
data (.readAllBytes in)]
|
|
(= (String. data) "Hello")))
|
|
|
|
(defn write-byte-by-byte []
|
|
(let [buffer (java.io.ByteArrayOutputStream.)
|
|
out (-> (Channels/newChannel buffer)
|
|
(channel->output-stream))]
|
|
(.write out (int \H))
|
|
(.write out (int \e))
|
|
(.write out (int \l))
|
|
(.write out (int \l))
|
|
(.write out (int \o))
|
|
(.close out)
|
|
(= (String. (.toByteArray buffer)) "Hello")))
|
|
|
|
(defn write-byte-array []
|
|
(let [buffer (java.io.ByteArrayOutputStream.)
|
|
out (-> (Channels/newChannel buffer)
|
|
(channel->output-stream))]
|
|
(.write out (.getBytes "Hello"))
|
|
(.close out)
|
|
(= (String. (.toByteArray buffer)) "Hello")))
|
|
|
|
(when (every? (fn [f] (f))
|
|
[read-byte-by-byte-test
|
|
read-byte-array
|
|
read-all
|
|
write-byte-by-byte
|
|
write-byte-array])
|
|
(println "Success")
|
|
:success)
|