(ns uncomplicate.clojure-cpp

"ClojureCPP is a Clojure library for integrating C/C++ based libraries available through JavaCPP.

(:require [clojure.string :refer [split]]

[uncomplicate.commons

[core :refer [Releaseable let-release Info info Bytes Entries bytesize size]]

[utils :refer [dragan-says-ex]]]

[uncomplicate.fluokitten

[core :as fluokitten]

[protocols :refer [Functor PseudoFunctor Magma Foldable foldmap fold Comonad]]])

(:import [java.nio Buffer ByteBuffer CharBuffer ShortBuffer IntBuffer LongBuffer FloatBuffer

DoubleBuffer]

java.nio.charset.Charset

[clojure.lang Seqable Keyword IFn$LLL IFn$LDD IFn$LOO]

[org.bytedeco.javacpp Pointer BytePointer CharPointer BoolPointer ShortPointer

IntPointer LongPointer FloatPointer DoublePointer CLongPointer FunctionPointer

PointerPointer SizeTPointer]

[uncomplicate.clojure_cpp StringPointer KeywordPointer]))

(defn physical-bytes

"Amount of non-shared physical memory currently used by the process.

(^long []

(Pointer/physicalBytes))

(^long [^long max-size]

(Pointer/physicalBytesInaccurate max-size)))

(defn available-physical-bytes

"Amount of physical memory that is available (free) from the operating system.

^long []

(Pointer/availablePhysicalBytes))

(defn max-physical-bytes

"The maximum amount of physical memory that should (could?) be used."

^long []

(Pointer/maxPhysicalBytes))

(defn total-physical-bytes

"The total amount of memory physically installed in the machine.

^long []

(Pointer/totalPhysicalBytes))

(defn tracked-bytes

"The amount of memory currently tracked by JavaCPP deallocators."

^long []

(Pointer/totalBytes))

(defn max-tracked-bytes

"The maximum amount of memory allowed to be tracked by JavaCPP deallocators."

^long []

(Pointer/maxBytes))

(defn pointers-count

"Number of pointers currently tracked by JavaCPP deallocators."

^long []

(Pointer/totalCount))

(defn safe

"If pointer `p` is neither `nil` nor `NULL`, returns `p`. Otherwise, throws an `IllegalArgumentexception`."

^Pointer [^Pointer p]

(if-not (Pointer/isNull p)

p

(throw (IllegalArgumentException. "Neither nil nor NULL pointer is allowed in this part of code. Please do not use non-initialized pointers here."))))

(defn safe2

"If pointer `p` is not `NULL`, returns `p`. Otherwise, throws an `IllegalArgumentexception`."

^Pointer [^Pointer p]

(if (or (nil? p) (< 0 (.address p)))

p

(throw (IllegalArgumentException. "NULL pointer is not allowed in this part of code. Please do not use non-initialized pointers here."))))

(defn malloc!

"Allocates the `byte-size` bytes of memory and returns a `Pointer` that manages it.

[^long byte-size]

(when-let [p (Pointer/malloc byte-size)]

(.capacity p byte-size)))

(defn calloc!

"Allocated a memory block of `n` elements each taking `element-size` bytes, and initializes

[^long n ^long element-size]

(when-let [p (Pointer/calloc n element-size)]

(.capacity p (* n element-size))))

(defn realloc!

"Attempts to resize a memory block previously created by `malloc!` or `calloc!`.

[^Pointer p ^long byte-size]

(when-let [p (Pointer/realloc p byte-size)]

(.capacity p byte-size)))

(defn free!

"Deallocates the memory block that was allocated by [[calloc!]], [[malloc!]], or [[realloc!]].

[^Pointer p]

(when-not (Pointer/isNull p)

(Pointer/free (.position p 0))

(.deallocate p)

(.setNull p))

p)

(defn memcmp

"Compares the first `byte-size` bytes of `p1` and `p2`. Returns a `long` integer, not a boolean!

(^long [^Pointer p1 ^Pointer p2 ^long byte-size]

(if (and (not (Pointer/isNull p1) (not (Pointer/isNull p2)))

(<= 0 byte-size (min (bytesize p1) (bytesize p2))))

(Pointer/memcmp p1 p2 byte-size)

(throw (IndexOutOfBoundsException.

(format "You're trying to compare data outside the bounds of %s memory block."

(if (< (bytesize p1) (bytesize p2)) "p1" "p2"))))))

(^long [^Pointer p1 ^Pointer p2]

(Pointer/memcmp p1 p2 (min (bytesize p1) (bytesize p2)))))

(defn memcpy!

"Copies `byte-size` bytes from `src` to `dst`, nad returns `dst`. If `byte-size` is not within

([^Pointer src ^Pointer dst ^long byte-size]

(if (and (not (Pointer/isNull src)) (not (Pointer/isNull dst))

(<= 0 byte-size (min (bytesize src) (bytesize dst))))

(Pointer/memcpy dst src byte-size)

(throw (IndexOutOfBoundsException.

(format "You're trying to copy outside the bounds of %s memory block."

(if (< (bytesize src) (bytesize dst)) "source" "destination"))))))

([^Pointer src ^Pointer dst]

(Pointer/memcpy dst src (min (bytesize src) (bytesize dst)))))

(defn memmove!

"Copies `byte-size` bytes from `src` to `dst`, and returns `dst`. A safer alternative

([^Pointer src ^Pointer dst ^long byte-size]

(if (and (not (Pointer/isNull src)) (not (Pointer/isNull dst))

(<= 0 byte-size (min (bytesize src) (bytesize dst))))

(Pointer/memmove dst src byte-size)

(throw (IndexOutOfBoundsException.

(format "You're trying to move data outside the bounds of %s memory block."

(if (< (bytesize src) (bytesize dst)) "source" "destination"))))))

([^Pointer src ^Pointer dst]

(Pointer/memmove dst src (min (bytesize src) (bytesize dst)))))

(defn memset!

"Sets `byte-size` bytes of `dst` to `value`, and returns `dst`.

[^Pointer dst ^long value ^long byte-size]

(if (and (not (Pointer/isNull dst)) (<= 0 byte-size (bytesize dst)))

(Pointer/memset dst value byte-size)

(throw (IndexOutOfBoundsException. "You're trying to set data outside the bounds of the destination memory block."))))

(defn zero!

"Initializes all elements in the memory block managed by `p` to zero."

[^Pointer p]

(if-not (Pointer/isNull p)

(.zero p)

p))

(def ^:const pointer-type

"A mapping of JavaCPP pointer types to appropriate keywords.

{DoublePointer :double

FloatPointer :float

LongPointer :long

IntPointer :int

ShortPointer :short

BytePointer :byte

CharPointer :char

CLongPointer :clong

SizeTPointer :size-t

BoolPointer :bool

FunctionPointer :function

PointerPointer :pointer

Pointer :default})

(def ^:const pointer-class

"A mapping of Java number types and related keywords to appropriate JavaCPP pointer types.

{:double DoublePointer

:float FloatPointer

:long LongPointer

:int IntPointer

:short ShortPointer

:byte BytePointer

:char CharPointer

:clong CLongPointer

:size-t SizeTPointer

:bool BoolPointer

:function FunctionPointer

:fn FunctionPointer

:pointer PointerPointer

:default Pointer

Double/TYPE DoublePointer

Float/TYPE FloatPointer

Long/TYPE LongPointer

Integer/TYPE IntPointer

Short/TYPE ShortPointer

Byte/TYPE BytePointer

Character/TYPE CharPointer

Boolean/TYPE BoolPointer})

(defn address

"Returns the address of pointer `p`"

^long [^Pointer p]

(.address p))

(defn null?

"Checks whether `p` points is `nil` or a NULL pointer. Typically, the NULL pointer

[^Pointer p]

(Pointer/isNull p))

(defn capacity

"Returns the capacity of `p`, as number of bytes if `p` is just a `Pointer`, or in number

^long [^Pointer p]

(.capacity p))

(defn capacity! ;;TODO think about removing this if Neanderthal and DD can use limit!

"Sets the capacity of `p`, as number of bytes if `p` is just a `Pointer`, or in number

[^Pointer p ^long n]

(.capacity p (max 0 n)))

(defn limit

"Returns the limit of `p`, as number of bytes if `p` is just a `Pointer`, or in number

^long [^Pointer p]

(.limit p))

(defn limit!

"Sets the limit of `p`, as number of bytes if `p` is just a `Pointer`, or in number

[^Pointer p ^long n]

(if (<= 0 n (.capacity p))

(.limit p n)

(throw (IndexOutOfBoundsException. (format "The requested position %d is larger than capacity %d."

n (.capacity p))))))

(defn position

"Returns the position where `p` begins, as number of bytes if `p` is just a `Pointer`,

^long [^Pointer p]

(.position p))

(defn position!

"Sets the position where `p` begins, as number of bytes if `p` is just a `Pointer`,

[^Pointer p ^long n]

(if (<= 0 n (.capacity p))

(.position p n)

(throw (IndexOutOfBoundsException. (format "The requested position %d is larger than capacity %d."

n (.capacity p))))))

(defn get-pointer

"Returns a new pointer that manages the memory block managed by `p`, starting from element `i`,

(^Pointer [^Pointer p]

(.getPointer p))

(^Pointer [^Pointer p ^long i]

(.getPointer p (min i (.capacity p))))

(^Pointer [^Pointer p type ^long i]

(.getPointer p (get pointer-class type type) i)))

(defn as-byte-buffer

"Returns a `ByteBuffer` representation of a pointer."

^ByteBuffer [^Pointer p]

(.asByteBuffer p))

(defn as-buffer ^Buffer [^Pointer p]

(.asBuffer p))

(defprotocol ^:no-doc PointerCreator

(pointer* [this] [this i] "Coerces a type into the appropriate `Pointer`."))

(defprotocol ^:no-doc RawPointerCreator

(raw* [this] "Creates a new instance of this pointer's type with the same size."))

(defprotocol TypedPointerCreator

(^PointerPointer pointer-pointer [this] [this charset] "Converts an object into `PointerPointer`.")

(^BytePointer byte-pointer [this] [this charset] "Converts an object into `BytePointer`.")

(^KeywordPointer keyword-pointer [this] [this charset] "Converts an object into `KeywordPointer`.")

(^StringPointer string-pointer [this] [this charset] "Converts an object into `StringPointer`.")

(^BoolPointer bool-pointer [this] "Converts an object into `BoolPointer`.")

(^CLongPointer clong-pointer [this] "Converts an object into `CLongPointer`.")

(^SizeTPointer size-t-pointer [this] "Converts an object into `SizeTPointer`.")

(^CharPointer char-pointer [this] "Converts an object into `CharPointer`.")

(^ShortPointer short-pointer [this] "Converts an object into `ShortPointer`.")

(^IntPointer int-pointer [this] "Converts an object into `IntPointer`.")

(^LongPointer long-pointer [this] "Converts an object into `LongPointer`.")

(^FloatPointer float-pointer [this] "Converts an object into `FloatPointer`.")

(^DoublePointer double-pointer [this] "Converts an object into `DoublePointer`.")

(^FunctionPointer function-pointer [this] "Converts an object into `FunctionPointer`."))

(defprotocol PointerVec

(pointer-vec [this]

"Returns a vector representation of elements in pointer's memory block,

taking into account pointer's type"))

(defn pointer

"Coerces `x` to appropriate `Pointer` subclass, with position indicated by index `i`.

(^Pointer [x]

(pointer* x))

(^Pointer [x i]

(pointer* x i)))

(defn ptr*

"Casts pointer `p` into `Pointer`. Useful when metadata for avoiding reflection

(^Pointer [^Pointer p]

p)

(^Pointer [^Pointer p ^long i]

(.getPointer p (min i (.capacity p)))))

(defn ptr

"Checks pointer `p` for safety with [[safe]] and casts it into `Pointer`.

(^Pointer [^Pointer p]

(safe p))

(^Pointer [^Pointer p ^long i]

(.getPointer (safe p) (min i (.capacity p)))))

(defn ptr2

"Checks pointer `p` for safety with [[safe2]] and casts it into `Pointer`.

(^Pointer [^Pointer p]

(safe2 p))

(^Pointer [^Pointer p ^long i]

(.getPointer (safe2 p) (min i (.capacity p)))))

(defn float-ptr*

"Casts pointer `p` into `FloatPointer`. Useful when metadata for avoiding reflection

(^FloatPointer [p]

p)

(^FloatPointer [^Pointer p ^long i]

(.getPointer p (min i (.capacity p)))))

(defn float-ptr

"Checks pointer `p` for safety with [[safe]] and casts it into `FloatPointer`.

(^FloatPointer [^FloatPointer p]

(cast FloatPointer (safe p)))

(^FloatPointer [^FloatPointer p ^long i]

(.getPointer ^FloatPointer (safe p) (min i (.capacity p)))))

(defn float-ptr2

"Checks pointer `p` for safety with [[safe2]] and casts it into `FloatPointer`.

(^FloatPointer [^FloatPointer p]

(cast FloatPointer (safe2 p)))

(^FloatPointer [^FloatPointer p ^long i]

(.getPointer ^FloatPointer (safe2 p) (min i (.capacity p)))))

(defn double-ptr*

"Casts pointer `p` into `DoublePointer`. Useful when metadata for avoiding reflection

(^DoublePointer [^DoublePointer p]

p)

(^DoublePointer [^Pointer p ^long i]

(.getPointer p (min i (.capacity p)))))

(defn double-ptr

"Checks pointer `p` for safety with [[safe]] and casts it into `DoublePointer`.

(^DoublePointer [^DoublePointer p]

(cast DoublePointer (safe p)))

(^DoublePointer [^DoublePointer p ^long i]

(.getPointer ^DoublePointer (safe p) (min i (.capacity p)))))

(defn double-ptr2

"Checks pointer `p` for safety with [[safe2]] and casts it into `DoublePointer`.

(^DoublePointer [^DoublePointer p]

(cast DoublePointer (safe2 p)))

(^DoublePointer [^DoublePointer p ^long i]

(.getPointer ^DoublePointer (safe2 p) (min i (.capacity p)))))

(defn long-ptr*

"Casts pointer `p` into `LongPointer`. Useful when metadata for avoiding reflection

(^LongPointer [^LongPointer p]

p)

(^LongPointer [^Pointer p ^long i]

(.getPointer p (min i (.capacity p)))))

(defn long-ptr

"Checks pointer `p` for safety with [[safe]] and casts it into `LongPointer`.

(^LongPointer [^LongPointer p]

(cast LongPointer (safe p)))

(^LongPointer [^LongPointer p ^long i]

(.getPointer ^LongPointer (safe p) (min i (.capacity p)))))

(defn long-ptr2

"Checks pointer `p` for safety with [[safe2]] and casts it into `LongPointer`.

(^LongPointer [^LongPointer p]

(cast LongPointer (safe2 p)))

(^LongPointer [^LongPointer p ^long i]

(.getPointer ^LongPointer (safe2 p) (min i (.capacity p)))))

(defn int-ptr*

"Casts pointer `p` into `IntPointer`. Useful when metadata for avoiding reflection

(^IntPointer [^IntPointer p]

p)

(^IntPointer [^Pointer p ^long i]

(.getPointer p (min i (.capacity p)))))

(defn int-ptr

"Checks pointer `p` for safety with [[safe]] and casts it into `IntPointer`.

(^IntPointer [^IntPointer p]

(cast IntPointer (safe p)))

(^IntPointer [^IntPointer p ^long i]

(.getPointer ^IntPointer (safe p) (min i (.capacity p)))))

(defn int-ptr2

"Checks pointer `p` for safety with [[safe2]] and casts it into `IntPointer`.

(^IntPointer [^IntPointer p]

(cast IntPointer (safe2 p)))

(^IntPointer [^IntPointer p ^long i]

(.getPointer ^IntPointer (safe2 p) (min i (.capacity p)))))

(defn short-ptr*

"Casts pointer `p` into `ShortPointer`. Useful when metadata for avoiding reflection

(^ShortPointer [^ShortPointer p]

p)

(^ShortPointer [^Pointer p ^long i]

(.getPointer p (min i (.capacity p)))))

(defn short-ptr

"Checks pointer `p` for safety with [[safe]] and casts it into `ShortPointer`.

(^ShortPointer [^ShortPointer p]

(cast ShortPointer (safe p)))

(^ShortPointer [^ShortPointer p ^long i]

(.getPointer ^ShortPointer (safe p) (min i (.capacity p)))))

(defn short-ptr2

"Checks pointer `p` for safety with [[safe2]] and casts it into `ShortPointer`.

(^ShortPointer [^ShortPointer p]

(cast ShortPointer (safe2 p)))

(^ShortPointer [^ShortPointer p ^long i]

(.getPointer ^ShortPointer (safe2 p) (min i (.capacity p)))))

(defn byte-ptr*

"Casts pointer `p` into `BytePointer`. Useful when metadata for avoiding reflection

(^BytePointer [^BytePointer p]

p)

(^BytePointer [^Pointer p ^long i]

(.getPointer p (min i (.capacity p)))))

(defn byte-ptr

"Checks pointer `p` for safety with [[safe]] and casts it into `BytePointer`.

(^BytePointer [^BytePointer p]

(cast BytePointer (safe p)))

(^BytePointer [^BytePointer p ^long i]

(.getPointer ^BytePointer (safe p) (min i (.capacity p)))))

(defn byte-ptr2

"Checks pointer `p` for safety with [[safe2]] and casts it into `BytePointer`.

(^BytePointer [^BytePointer p]

(cast BytePointer (safe2 p)))

(^BytePointer [^BytePointer p ^long i]

(.getPointer ^BytePointer (safe2 p) (min i (.capacity p)))))

(defn clong-ptr*

"Casts pointer `p` into `CLongPointer`. Useful when metadata for avoiding reflection

(^CLongPointer [^CLongPointer p]

p)

(^CLongPointer [^Pointer p ^long i]

(.getPointer p (min i (.capacity p)))))

(defn clong-ptr

"Checks pointer `p` for safety with [[safe]] and casts it into `CLongPointer`.

(^CLongPointer [^CLongPointer p]

(cast CLongPointer (safe p)))

(^CLongPointer [^CLongPointer p ^long i]

(.getPointer ^CLongPointer (safe p) (min i (.capacity p)))))

(defn clong-ptr2

"Checks pointer `p` for safety with [[safe2]] and casts it into `CLongPointer`.

(^CLongPointer [^CLongPointer p]

(cast CLongPointer (safe2 p)))

(^CLongPointer [^CLongPointer p ^long i]

(.getPointer ^CLongPointer (safe2 p) (min i (.capacity p)))))

(defn size-t-ptr*

"Casts pointer `p` into `SizeTPointer`. Useful when metadata for avoiding reflection

(^SizeTPointer [^SizeTPointer p]

p)

(^SizeTPointer [^Pointer p ^long i]

(.getPointer p (min i (.capacity p)))))

(defn size-t-ptr

"Checks pointer `p` for safety with [[safe]] and casts it into `SizeTPointer`.

(^SizeTPointer [^SizeTPointer p]

(cast SizeTPointer (safe p)))

(^SizeTPointer [^SizeTPointer p ^long i]

(.getPointer ^SizeTPointer (safe p) (min i (.capacity p)))))

(defn size-t-ptr2

"Checks pointer `p` for safety with [[safe2]] and casts it into `SizeTPointer`.

(^SizeTPointer [^SizeTPointer p]

(cast SizeTPointer (safe2 p)))

(^SizeTPointer [^SizeTPointer p ^long i]

(.getPointer ^SizeTPointer (safe2 p) (min i (.capacity p)))))

(defn bool-ptr*

"Casts pointer `p` into `BoolPointer`. Useful when metadata for avoiding reflection

(^BoolPointer [^BoolPointer p]

p)

(^BoolPointer [^Pointer p ^long i]

(.getPointer p (min i (.capacity p)))))

(defn bool-ptr

"Checks pointer `p` for safety with [[safe]] and casts it into `BoolPointer`.

(^BoolPointer [^BoolPointer p]

(cast BoolPointer (safe p)))

(^BoolPointer [^BoolPointer p ^long i]

(.getPointer ^BoolPointer (safe p) (min i (.capacity p)))))

(defn bool-ptr2

"Checks pointer `p` for safety with [[safe2]] and casts it into `BoolPointer`.

(^BoolPointer [^BoolPointer p]

(cast BoolPointer (safe2 p)))

(^BoolPointer [^BoolPointer p ^long i]

(.getPointer ^BoolPointer (safe2 p) (min i (.capacity p)))))

(defn char-ptr*

"Casts pointer `p` into `CharPointer`. Useful when metadata for avoiding reflection

(^CharPointer [^CharPointer p]

p)

(^CharPointer [^Pointer p ^long i]

(.getPointer p (min i (.capacity p)))))

(defn char-ptr

"Checks pointer `p` for safety with [[safe]] and casts it into `CharPointer`.