deercreeklabs.baracus — deercreeklabs/baracus 0.2.0

b64->byte-array clj/s

(b64->byte-array s)

Inputs: [s :- (s/maybe s/Str)] Returns: (s/maybe ByteArray)

byte-array clj/s≠

clj

(byte-array size-or-seq)

(byte-array size init-val-or-seq)

cljs

(byte-array G__3320)

(byte-array G__3324 G__3325)

Inputs: ([size-or-seq :- s/Any] [size :- s/Int init-val-or-seq :- (s/if sequential? [s/Any] s/Any)]) Returns: ByteArray

Construct a byte array. Args:

• size-or-seq: An integer size or sequence of bytes.

byte-array->b64 clj/s

(byte-array->b64 b)

Inputs: [b :- (s/maybe ByteArray)] Returns: (s/maybe s/Str)

byte-array->debug-str clj/s

(byte-array->debug-str ba)

Inputs: [ba :- ByteArray] Returns: s/Str

byte-array->fragments clj/s

(byte-array->fragments ba fragment-size)

Inputs: [ba :- (s/maybe ByteArray) fragment-size :- s/Int] Returns: (s/maybe [ByteArray])

byte-array->hex-str clj/s

(byte-array->hex-str ba)

Inputs: [ba :- (s/maybe ByteArray)] Returns: (s/maybe s/Str)

byte-array->utf8 clj/s

(byte-array->utf8 ba)

Inputs: [ba :- (s/maybe ByteArray)] Returns: (s/maybe s/Str)

byte-array? clj/s

(byte-array? arg)

Inputs: [arg :- s/Any] Returns: s/Bool

Tests if the argument is a byte array

ByteArray clj/s

char->int clj/s

(char->int ch)

concat-byte-arrays clj/s

(concat-byte-arrays arrays)

Inputs: [arrays :- (s/maybe [(s/maybe ByteArray)])] Returns: (s/maybe ByteArray)

Concatenate a sequence of byte arrays

decode-int clj/s

(decode-int ba)

Inputs: [ba :- ByteArray] Returns: [(s/one s/Int :int) (s/optional ByteArray :unread-remainder)]

Takes an zig-zag encoded byte array and reads an integer from it. Returns a vector of the integer and, optionally, any unread bytes.

deflate clj

(deflate data)

Inputs: [data :- (s/maybe ByteArray)] Returns: (s/maybe ByteArray)

encode-int clj/s

(encode-int i)

Inputs: [i :- s/Int] Returns: ByteArray

Zig zag encodes an integer. Returns the encoded bytes.

equivalent-byte-arrays? clj/s

(equivalent-byte-arrays? a b)

Inputs: [a :- ByteArray b :- ByteArray] Returns: s/Bool

Test if two byte arrays are equivalent. Normal Clojure = on byte arrays checks identity, not equality. Note that this is an O(n) operation.

hex-str->byte-array clj/s

(hex-str->byte-array s)

Inputs: [s :- (s/maybe s/Str)] Returns: (s/maybe ByteArray)

inflate clj

(inflate deflated-data)

Inputs: [deflated-data :- (s/maybe ByteArray)] Returns: (s/maybe ByteArray)

Nil clj/s

read-byte-array-from-file clj

(read-byte-array-from-file filename)

Inputs: [filename :- s/Str] Returns: ByteArray

reverse-byte-array clj/s

(reverse-byte-array ba)

Inputs: [ba :- (s/maybe ByteArray)] Returns: (s/maybe ByteArray)

Returns a new byte array with bytes reversed.

sha256 clj/s

(sha256 ba)

Inputs: [ba :- ByteArray] Returns: ByteArray

slice-byte-array clj/s≠

clj

(slice-byte-array ba)

(slice-byte-array ba start)

(slice-byte-array ba start end)

cljs

(slice-byte-array G__3349)

(slice-byte-array G__3353 G__3354)

(slice-byte-array G__3358 G__3359 G__3360)

Inputs: ([ba :- (s/maybe ByteArray)] [ba :- (s/maybe ByteArray) start :- s/Num] [ba :- (s/maybe ByteArray) start :- s/Num end :- s/Num]) Returns: (s/maybe ByteArray)

Return a slice of the given byte array. Args: - ba - Byte array to be sliced. Required. - start - Start index. Optional. Defaults to 0. - end - End index. Optional. If not provided, the slice will extend to the end of the array. The returned slice will not contain the byte at the end index position, i.e.: the slice fn uses a half-open interval.

utf8->byte-array clj/s

(utf8->byte-array s)

Inputs: [s :- (s/maybe s/Str)] Returns: (s/maybe ByteArray)

write-byte-array-to-file clj

(write-byte-array-to-file filename ba)

Inputs: [filename :- s/Str ba :- ByteArray] Returns: Nil