From 96dfff04a0bfd88c17be9b56a0be7b6476e79a3d Mon Sep 17 00:00:00 2001
From: Joshua Suskalo <joshua@suskalo.org>
Date: Fri, 4 Oct 2024 11:59:42 -0400
Subject: [PATCH 1/6] Remove reference to fixed "known issue" from readme

---
 README.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/README.md b/README.md
index a0bbbd2..c779202 100644
--- a/README.md
+++ b/README.md
@@ -1130,7 +1130,6 @@ release:
   ```
   Unable to find static field: ACC_OPEN in interface org.objectweb.asm.Opcodes
   ```
-- Pointer wrapper types like `[::mem/pointer ::mem/int]` currently use one too many layers of indirection. This is fixed on develop.
 
 ## Future Plans
 These features are planned for future releases.

From d0bfd20117d7f5a3c9d49cabd64f1bf95258474b Mon Sep 17 00:00:00 2001
From: Joshua Suskalo <joshua@suskalo.org>
Date: Fri, 4 Oct 2024 16:00:57 -0400
Subject: [PATCH 2/6] Pare down the readme to an acceptable size

---
 README.md | 1054 ++---------------------------------------------------
 1 file changed, 29 insertions(+), 1025 deletions(-)

diff --git a/README.md b/README.md
index c779202..23831ac 100644
--- a/README.md
+++ b/README.md
@@ -9,11 +9,11 @@ on ease of use, including functions and macros for creating wrappers to allow
 the resulting native functions to act just like Clojure ones, however this
 doesn't remove the ability to write systems which minimize the cost of
 marshaling data and optimize for performance, to make use of the low-level
-access Panama gives us.
+access the FF&M API gives us.
 
 ## Installation
-This library is available on Clojars. Add one of the following entries to the
-`:deps` key of your `deps.edn`:
+This library is available on Clojars, or as a git dependency. Add one of the
+following entries to the `:deps` key of your `deps.edn`:
 
 ```clojure
 org.suskalo/coffi {:mvn/version "1.0.486"}
@@ -56,7 +56,7 @@ documentation.
 
 When creating an executable jar file, you can avoid the need to pass this
 argument by adding the manifest attribute `Enable-Native-Access: ALL-UNNAMED` to
-your jar.
+your jar. See your build tool's documentation for how to add this.
 
 Coffi also includes support for the linter clj-kondo. If you use clj-kondo and
 this library's macros are not linting correctly, you may need to install the
@@ -68,14 +68,13 @@ $ clj-kondo --copy-configs --dependencies --lint "$(clojure -Spath)"
 ```
 
 ## Usage
-There are two major components to coffi and interacting with native code:
-manipulating off-heap memory, and loading native code for use with Clojure.
-
-In the simplest cases, the native functions you call will work exclusively with
-built-in types, for example the function `strlen` from libc.
+The two main namespaces are `coffi.mem` which provides functions for allocating
+and manipulating off-heap memory and (de)serializing values, and `coffi.ffi`
+which can load native libraries, declare native function wrappers, and
+(de)serialize functions as callbacks.
 
 ```clojure
-(require '[coffi.mem :as mem :refer [defalias]])
+(require '[coffi.mem :as mem])
 (require '[coffi.ffi :as ffi :refer [defcfn]])
 
 (defcfn strlen
@@ -84,657 +83,34 @@ built-in types, for example the function `strlen` from libc.
 
 (strlen "hello")
 ;; => 5
-```
 
-The first argument to `defcfn` is the name of the Clojure var that will hold the
-native function reference, followed by an optional docstring and attribute map,
-then the C function identifier, including the name of the native symbol, a
-vector of argument types, and the return type.
-
-If you wish to use a native function as an anonymous function, it can be done
-with the `cfn` function.
-
-```clojure
-((ffi/cfn "strlen" [::mem/c-string] ::mem/long) "hello")
-;; => 5
-```
-
-If you want to use functions from libraries other than libc, then you'll need to
-load them. Two functions are provided for this, `load-system-library`, and
-`load-library`. `load-system-library` takes a string which represents the name
-of a library that should be loaded via system lookup.
-
-```clojure
 (ffi/load-system-library "z")
 ```
 
-This will load libz from the appropriate place on the user's load path.
-
-Alternatively, `load-library` takes a file path to a dynamically loaded library.
-
-```clojure
-(ffi/load-library "lib/libz.so")
-```
-
-This will load libz from the lib subdirectory of the current working directory.
-As you can see this requires the entire filename, including platform-specific
-file extensions.
-
-If a library is attempted to be loaded but doesn't exist or otherwise can't be
-loaded, an exception is thrown. This can be convenient as any namespace with a
-`load-library` call at the top level cannot be required without the library
-being able to be loaded.
-
-### Primitive Types
-Coffi defines a basic set of primitive types:
-- byte
-- short
-- int
-- long
-- char
-- float
-- double
-- pointer
-
-Each of these types maps to their C counterpart. Values of any of these
-primitive types except for `pointer` will be cast with their corresponding
-Clojure function when they are passed as arguments to native functions.
-Additionally, the `c-string` type is defined, although it is not primitive.
-
-### Composite Types
-In addition, some composite types are also defined in coffi, including struct
-and union types (unions will be discussed with serialization and
-deserialization). For an example C struct and function:
-
-```c
-typedef struct point {
-    float x;
-    float y;
-} Point;
-
-Point zero(void) {
-    Point res = {};
-
-    res.x = 0.0;
-    res.y = 0.0;
-
-    return res;
-}
-```
-
-The corresponding coffi definition is like so:
-
-```clojure
-(defcfn zero-point
-  "zero" [] [::mem/struct [[:x ::mem/float] [:y ::mem/float]]])
-
-(zero-point)
-;; => {:x 0.0,
-;;     :y 0.0}
-```
-
-Writing out struct definitions like this every time would get tedious, so the
-macro `defalias` is used to define a struct alias.
-
-```clojure
-(defalias ::point
-  [::mem/struct
-   [[:x ::mem/float]
-    [:y ::mem/float]]])
-
-(defcfn zero-point
-  "zero" [] ::point)
-```
-
-Struct definitions do not include any padding by default. Functions for
-transforming struct types to include padding conforming to various standards can
-be found in `coffi.layout`.
-
-``` clojure
-(require '[coffi.layout :as layout])
-
-(defalias ::needs-padding
-  (layout/with-c-layout
-   [::mem/struct
-    [[:a ::mem/char]
-     [:x ::mem/float]]]))
-
-(mem/size-of ::needs-padding)
-;; => 8
-
-(mem/align-of ::needs-padding)
-;; => 4
-```
-
-Values deserialized with types produced from layout functions may include an
-extra `:coffi.layout/padding` key with a nil value.
-
-A limitation of the `defcfn` macro in its current form is that types provided to
-it must be provided in a literal form, not as an expression that evaluates to a
-type. This means that if you wish to use a layout function on a struct you must
-define an alias for it before the type can be used as a type in `defcfn`.
-
-In cases where a pointer to some data is required to pass as an argument to a
-native function, but doesn't need to be read back in, the `pointer` primitive
-type can take a type argument.
-
-```clojure
-[::mem/pointer ::mem/int]
-```
-
-Arrays are also supported via a type argument. Keep in mind that they are the
-array itself, and not a pointer to the array like you might see in certain cases
-in C.
-
-```clojure
-[::mem/array ::mem/int 3]
-```
-
-### Callbacks
-In addition to these composite types, there is also support for Clojure
-functions.
-
-```clojure
-[::ffi/fn [::mem/c-string] ::mem/int]
-```
-
-Be aware though that if an exception is thrown out of a callback that is called
-from C, the JVM will crash. The resulting crash log should include the exception
-type and message in the registers section, but it's important to be aware of all
-the same. Ideally you should test your callbacks before actually passing them to
-native code.
-
-When writing a wrapper library for a C library, it may be a good choice to wrap
-all passed Clojure functions in an additional function which catches all
-throwables, potentially notifies the user in some manner (e.g. logging), and
-returns a default value. This is on the wrapper library's developer to decide
-when and where this is appropriate, as in some cases no reasonable default
-return value can be determined and it is most sensible to simply crash the JVM.
-This is the reason that coffi defaults to this behavior, as in the author's
-opinion it is better to fail hard and fast rather than to attempt to produce a
-default and cause unexpected behavior later.
-
-Another important thing to keep in mind is the expected lifetime of the function
-that you pass to native code. For example it is perfectly fine to pass an
-anonymous function to a native function if the callback will never be called
-again once the native function returns. If however it saves the callback for
-later use the JVM may collect it prematurely, causing a crash when the callback
-is later called by native code.
-
-### Variadic Functions
-Some native functions can take any number of arguments, and in these cases coffi
-provides `vacfn-factory` (for "varargs C function factory").
-
-```clojure
-(def printf-factory (ffi/vacfn-factory "printf" [::mem/c-string] ::mem/int))
-```
-
-This returns a function of the types of the rest of the arguments which itself
-returns a native function wrapper.
-
-```clojure
-(def print-int (printf-factory ::mem/int))
-
-(print-int "Some integer: %d\n" 5)
-;; Some integer: 5
-```
-
-At the moment there is no equivalent to `defcfn` for varargs functions.
-
-Some native functions that are variadic use the type `va_list` to make it easier
-for other languages to call them in their FFI. At the time of writing, coffi
-does not support va-list, however it is a planned feature.
-
-### Global Variables
-Some libraries include global variables or constants accessible through symbols.
-To start with, constant values stored in symbols can be fetched with `const`, or
-the parallel macro `defconst`
-
-```clojure
-(def some-const (ffi/const "some_const" ::mem/int))
-(ffi/defconst some-const "some_const" ::mem/int)
-```
-
-This value is fetched once when you call `const` and is turned into a Clojure
-value. If you need to refer to a global variable, then `static-variable` (or
-parallel `defvar`) can be used to create a reference to the native value.
-
-```clojure
-(def some-var (ffi/static-variable "some_var" ::mem/int))
-(ffi/defvar some-var "some_var" ::mem/int)
-```
-
-This variable is an `IDeref`. Each time you dereference it, the value will be
-deserialized from the native memory and returned. Additional functions are
-provided for mutating the variable.
-
-```clojure
-(ffi/freset! some-var 5)
-;; => 5
-@some-var
-;; => 5
-```
-
-Be aware however that there is no synchronization on these types. The value
-being read is not read atomically, so you may see an inconsistent state if the
-value is being mutated on another thread.
-
-A parallel function `fswap!` is also provided, but it does not provide any
-atomic semantics either.
-
-The memory that backs the static variable can be fetched with the function
-`static-variable-segment`, which can be used to pass a pointer to the static
-variable to native functions that require it.
-
-### Complex Wrappers
-Some functions require more complex code to map nicely to a Clojure function.
-The `defcfn` macro provides facilities to wrap the native function with some
-Clojure code to make this easier.
-
-```clojure
-(defcfn takes-array
-  "takes_array_with_count" [::mem/pointer ::mem/long] ::mem/void
-  native-fn
-  [ints]
-  (let [arr-len (count ints)
-        int-array (mem/serialize ints [::mem/array ::mem/int arr-len])]
-    (native-fn int-array arr-len)))
-```
-
-The symbol `native-fn` can be any unqualified symbol, and names the native
-function being wrapped. It must be called in the function body below if you want
-to call the native code.
-
-This `serialize` function has a paired `deserialize`, and allows marshaling
-Clojure data back and forth to native data structures.
-
-This can be used to implement out variables often seen in native code.
-
-```clojure
-(defcfn out-int
-  "out_int" [::mem/pointer] ::mem/void
-  native-fn
-  [i]
-  (let [int-ptr (mem/serialize i [::mem/pointer ::mem/int])]
-    (native-fn int-ptr)
-    (mem/deserialize int-ptr [::mem/pointer ::mem/int])))
-```
-
-### Arenas
-In order to serialize any non-primitive type (such as the previous
-`[::mem/pointer ::mem/int]`), off-heap memory needs to be allocated. When memory
-is allocated inside the JVM, the memory is associated with an arena. Because
-none was provided here, the arena is an implicit arena, and the memory will be
-freed when the serialized object is garbage collected.
-
-In many cases this is not desirable, because the memory is not freed in a
-deterministic manner, causing garbage collection pauses to become longer, as
-well as changing allocation performance. Instead of an implicit arena, there
-are other kinds of arenas as well. A `confined-arena` is a thread-local arena.
-Confined arenas are `Closeable`, which means they should usually be used in a
-`with-open` form. When a `confined-arena` is closed, it immediately frees all
-the memory associated with it. The previous example, `out-int`, can be
-implemented with a confined arena.
-
-```clojure
-(defcfn out-int
-  "out_int" [::mem/pointer] ::mem/void
-  native-fn
-  [i]
-  (with-open [arena (mem/confined-arena)]
-    (let [int-ptr (mem/serialize i [::mem/pointer ::mem/int] arena)]
-      (native-fn int-ptr)
-      (mem/deserialize int-ptr [::mem/pointer ::mem/int]))))
-```
-
-This will free the pointer immediately upon leaving the function.
-
-When memory needs to be accessible from multiple threads, there's
-`shared-arena`. When a `shared-arena` is `.close`d, it will release all its
-associated memory immediately, and so this should only be done once all other
-threads are done accessing memory associated with it.
-
-In addition, two non-`Closeable` arenas are `global-arena`, which never frees
-the resources associated with it, and `auto-arena`, which is an arena that frees
-its resources once all of them are unreachable during a garbage collection
-cycle, like an implicit arena, but potentially for multiple allocations rather
-than just one.
-
-### Serialization and Deserialization
-Custom serializers and deserializers may also be created. This is done using two
-sets of three multimethods which can be extended by the user. For any given
-type, only one set need be implemented.
-
-Two examples of custom types are given here, one is a 3d vector, and the other
-an example of a tagged union.
-
-#### Vector3
-For the vector type, it will serialize to a pointer to an array of three floats.
-
-The multimethod `primitive-type` returns the primitive type that a given type
-serializes to. For this example, it should be a pointer.
-
-```clojure
-(defmethod mem/primitive-type ::vector
-  [_type]
-  ::mem/pointer)
-```
-
-For any type which doesn't serialize to a primitive, it returns nil, and
-therefore need not be overriden.
-
-Next is `serialize*` and `deserialize*`, multimethods that work with types that
-serialize to primitives.
-
-```clojure
-(defmethod mem/serialize* ::vector
-  [obj _type arena]
-  (mem/serialize obj [::mem/array ::mem/float 3] arena))
-
-(defmethod mem/deserialize* ::vector
-  [segment _type]
-  (mem/deserialize (mem/reinterpret segment (mem/size-of [::mem/array ::mem/float 3]))
-                   [::mem/array ::mem/float 3]))
-```
-
-The `reinterpret` function allows you to take a segment and decorate it with a
-new size, and possibly associate it with an arena or add cleanup functions on
-it.
-
-In cases like this where we don't know the arena of the pointer, we could use
-`reinterpret` to ensure it's freed. For example if a `free-vector!` function
-that takes a pointer exists, we could use this:
-
-```clojure
-(defcfn returns-vector
-  "returns_vector" [] ::mem/pointer
-  native-fn
-  [arena]
-  (let [ret-ptr (native-fn)]
-    (-> (reinterpret ret-ptr (mem/size-of ::vector) arena free-vector!)
-        (deserialize ::vector))))
-```
-
-This function takes an arena and returns the deserialized vector, and it will
-free the pointer when the arena closes.
-
-#### Tagged Union
-For the tagged union type, we will represent the value as a vector of a keyword
-naming the tag and the value. The type itself will need to take arguments,
-similar to `struct`. For example, if we were to represent a result type like in
-Rust, we might have the following values:
-
-```clojure
-[:ok 5]
-[:err "Invalid number format"]
-```
-
-To represent this, we can have a `tagged-union` type. For this instance of the
-result type, it may look like this:
-
-```clojure
-[::tagged-union [:ok :err] {:ok ::mem/int :err ::mem/c-string}]
-```
-
-The native representation of these objects is a struct of the tag and a union of
-the value. In order to correctly serialize the data and pass it to native code,
-we need a representation of the native layout of the data. The `c-layout`
-multimethod provides that.
-
-```clojure
-(defmethod mem/c-layout ::tagged-union
-  [[_tagged-union tags type-map]]
-  (mem/c-layout [::mem/struct
-                 [[:tag ::mem/long]
-                  [:value [::mem/union (vals type-map)]]]]))
-```
-
-Types with type arguments are represented as vectors of the type name and any
-additional arguments. The type name is what is dispatched on for the
-multimethods.
-
-Now that we have a native layout, we need to be able to serialize and
-deserialize the value into and out of memory segments. This is accomplished with
-`serialize-into` and `deserialize-from`.
-
-```clojure
-(defn item-index
-  "Gets the index of the first occurance of `item` in `coll`."
-  [coll item]
-  (first
-   (->> coll
-        (map-indexed vector)
-        (filter (comp #{item} second))
-        (map first))))
-
-(defmethod mem/serialize-into ::tagged-union
-  [obj [_tagged-union tags type-map] segment arena]
-  (mem/serialize-into
-   {:tag (item-index tags (first obj))
-    :value (second obj)}
-   [::mem/struct
-    [[:tag ::mem/long]
-     [:value (get type-map (first obj))]]]
-   segment
-   arena))
-```
-
-This serialization method is rather simple, it just turns the vector value into
-a map, and serializes it as a struct, choosing the type of the value based on
-the tag.
-
-```clojure
-(defmethod mem/deserialize-from ::tagged-union
-  [segment [_tagged-union tags type-map]]
-  (let [tag (mem/deserialize-from segment ::mem/long)]
-    [(nth tags tag)
-     (mem/deserialize-from
-      (mem/slice segment (mem/size-of ::mem/long))
-      (get type-map tag))]))
-```
-
-Deserialization is a little more complex. First the tag is retrieved from the
-beginning of the segment, and then the type of the value is decided based on
-that before it is deserialized.
-
-### Unions
-In the last section the custom serialization and deserialization of a tagged
-union used a union from coffi in order to define the native layout, but not for
-actual serialization or deserialization. This is intentional. A union in coffi
-is rather limited. It can be serialized, but not deserialized without external
-information.
-
-```clojure
-[::mem/union
- #{::mem/float ::mem/double}
- :dispatch #(cond
-             (float? %) ::mem/float
-             (double? %) ::mem/double)]
-```
-
-This is a minimal union in coffi. If the `:dispatch` keyword argument is not
-passed, then the union cannot be serialized, as coffi would not know which type
-to serialize the values as. In the example with a tagged union, a dispatch
-function was not provided because the type was only used for the native layout.
-
-In addition to a dispatch function, when serializing a union an extract function
-may also be provided. In the case of the value in the tagged union from before,
-it could be represented for serialization purposes like so:
-
-```clojure
-[::mem/union
- #{::mem/int ::mem/c-string}
- :dispatch #(case (first %)
-              :ok ::mem/int
-              :err ::mem/c-string)
- :extract second]
-```
-
-This union however would not include the tag when serialized.
-
-If a union is deserialized, then all that coffi does is to allocate a new
-segment of the appropriate size with an implicit arena so that it may later be
-garbage collected, and copies the data from the source segment into it. It's up
-to the user to call `deserialize-from` on that segment with the appropriate
-type.
-
-### Unwrapped Native Handles
-Some native libraries work with handles to large amounts of data at once, making
-it undesirable to marshal data back and forth from Clojure, both because it's
-not necessary to work with the data in Clojure directly, or also because of the
-high (de)serialization costs associated with marshaling. In cases like these,
-unwrapped native handles are desirable.
-
-The functions `make-downcall` and `make-varargs-factory` are also provided to
-create raw function handles.
-
-```clojure
-(def raw-strlen (ffi/make-downcall "strlen" [::mem/c-string] ::mem/long))
-(raw-strlen (mem/serialize "hello" ::mem/c-string))
-;; => 5
-```
-
-With raw handles, the argument types are expected to exactly match the types
-expected by the native function. For primitive types, those are primitives. For
-pointers, that is `MemorySegment`, and for composite types like structs and
-unions, that is also `MemorySegment`. `MemorySegment` comes from the
-`java.lang.foreign` package.
-
-In addition, when a raw handle returns a composite type represented with a
-`MemorySegment`, it requires an additional first argument, a `SegmentAllocator`,
-which can be acquired with `arena-allocator` to get one associated with a
-specific arena. The returned value will live until that arena is released.
-
-In addition, function types can be specified as being raw, in the following
-manner:
-
-```clojure
-[::ffi/fn [::mem/int] ::mem/int :raw-fn? true]
-```
-
-Clojure functions serialized to this type will have their arguments and return
-value exactly match the types specified and will not perform any serialization
-or deserialization at their boundaries.
-
-One important caveat to consider when writing wrappers for performance-sensitive
-functions is that the convenience macro `defcfn` that coffi provides will
-already perform no serialization or deserialization on primitive arguments and
-return types, so for functions with only primitive argument and return types
-there is no performance reason to choose unwrapped native handles over the
-convenience macro.
-
-### Manual (De)Serialization
-Coffi uses multimethods to dispatch to (de)serialization functions to enable
-code that's generic over the types it operates on. However, in cases where you
-know the exact types that you will be (de)serializing and the multimethod
-dispatch overhead is too high a cost, it may be appropriate to manually handle
-(de)serializing data. This will often be done paired with [Unwrapped Native
-Handles](#unwrapped-native-handles).
-
-Convenience functions are provided to both read and write all primitive types
-and addresses, including byte order.
-
-As an example, when wrapping a function that returns an array of big-endian
-floats, the following code might be used.
-
-``` clojure
-;; int returns_float_array(float **arr)
-(def ^:private returns-float-array* (ffi/make-downcall "returns_float_array" [::mem/pointer] ::mem/int))
-;; void releases_float_array(float *arr)
-(def ^:private release-floats* (ffi/make-downcall "releases_float_array" [::mem/pointer] ::mem/void))
-
-(defn returns-float-array
-  []
-  (with-open [arena (mem/confined-arena)]
-    ;; float *out_floats;
-    ;; int num_floats = returns_float_array(&out_floats);
-    (let [out-floats (mem/alloc mem/pointer-size arena)
-          num-floats (returns-float-array* out-floats)
-          floats-addr (mem/read-address out-floats)
-          floats-slice (mem/reinterpret floats-addr (unchecked-multiply-int mem/float-size num-floats))]
-      ;; Using a try/finally to perform an operation when the stack frame exits,
-      ;; but not to try to catch anything.
-      (try
-        (loop [floats (transient [])
-               index 0]
-          (if (>= index num-floats)
-            (persistent! floats)
-            (recur (conj! floats (mem/read-float floats-slice
-                                                 (unchecked-multiply-int index mem/float-size)
-                                                 mem/big-endian))
-                   (unchecked-inc-int index))))
-        (finally
-          (release-floats* floats-addr))))))
-```
-
-The above code manually performs all memory operations rather than relying on
-coffi's dispatch. This will be more performant, but because multimethod overhead
-is usually relatively low, it's recommended to use the multimethod variants for
-convenience in colder functions.
-
-### Data Model
-In addition to the macros and functions provided to build a Clojure API for
-native libraries, facilities are provided for taking data and loading all the
-symbols specified by it. This can be useful if a library provides (or an
-external provider maintains) a data representation of their API, as Clojure data
-to represent it may be programmatically generated from these sources.
-
-The data to represent an API is a map with the following form:
-
-```clojure
-(def strlen-libspec
-  {:strlen {:type :function
-            :symbol "strlen"
-            :function/args [::mem/c-string]
-            :function/ret ::mem/long}})
-```
-
-Each key in this map represents a single symbol to be loaded. The value is a map
-with at least the keys `:type` and `:symbol`. These are the currently recognized
-types:
-
-- function
-- varargs-factory
-- const
-- static-var
-
-Each one has its own set of additional keys which can be added to the map. Both
-`function` and `varargs-factory` have the three keys `:function/args`,
-`:function/ret`, and `:function/raw-fn?`. The `const` type has `:const/type` and
-`static-var` has `:static-var/type`.
-
-This data can be passed to the function `reify-libspec`, which will take the
-data and return a map from the same keys as the input map to whatever value is
-appropriate for a given symbol type (e.g. a Clojure function for `function`, a
-value for `const`, etc.).
-
-```clojure
-(ffi/reify-libspec strlen-libspec)
-;; => {:strlen #function[...]}
-```
-
-This functionality can be extended by specifying new types as implementations of
-the multimethod `reify-symbolspec`, although it's recommended that for any
-library authors who do so, namespaced keywords be used to name types.
+In the `coffi.mem` namespace there are types for all the signed primitive
+numeric types in C, plus `::mem/pointer` and `::mem/c-string`, and ways to use
+malli-like type declarations to define structs, unions, arrays, enums, and
+flagsets.
 
 ## Alternatives
-**ALTERNATIVES INFORMATION IS OUT OF DATE. THE LINKS ARE FINE, BUT DESCRIPTIONS WILL BE UPDATED AT A LATER DATE.**
-
 This library is not the only Clojure library providing access to native code. In
-addition the following libraries exist:
+addition the following libraries (among others) exist:
 
 - [dtype-next](https://github.com/cnuernber/dtype-next)
 - [tech.jna](https://github.com/techascent/tech.jna)
 - [clojure-jna](https://github.com/Chouser/clojure-jna)
 
-Dtype-next has support for Java versions 8-16 and GraalVM, but is focused
+Dtype-next has support for Java versions 8-15, 17+, and GraalVM, but is focused
 strongly on array-based programming, as well as being focused on keeping memory
 in the native side rather than marshaling data to and from Clojure-native
-structures. In Java 16, this uses the first iteration of Panama, while in other
-Java versions it uses JNA.
+structures. In Java 17+, this uses the Foreign Function & Memory API (a part of
+Project Panama until stabilization in JDK 22), while in other Java versions it
+uses JNA.
 
 Tech.jna and clojure-jna both use the JNA library in all cases, and neither
-provide support for dealing with struct types or callbacks.
+provide explicit support for callbacks. JNA allows the use of
+`java.nio.ByteBuffer`s to pass structs by value, and both libraries provide ways
+to use this by-value construction to call by-reference apis.
 
 An additional alternative to coffi is to directly use the JNI, which is the
 longest-standing method of wrapping native code in the JVM, but comes with the
@@ -742,385 +118,13 @@ downside that it requires you to write both native and Java code to use, even if
 you only intend to use it from Clojure.
 
 If your application needs to be able to run in earlier versions of the JVM than
-17, or you don't want to use incubator functionality, you should consider these
-other options. Dtype-next provides the most robust support for native code, but
-if you are wrapping a simple library then the other libraries may be more
-appealing, as they have a smaller API surface area and it's easier to wrap
-functions.
+22, you should consider these other options. Dtype-next provides the most robust
+support for native code, but if you are wrapping a simple library then the other
+libraries may be more appealing, as they have a smaller API surface area and
+it's easier to wrap functions.
 
-### Benchmarks
-**BENCHMARKS FOR COFFI AND DTYPE-NEXT ARE BASED ON AN OLD VERSION. NEW BENCHMARKS WILL BE CREATED SOON.**
-
-An additional consideration when thinking about alternatives is the performance
-of each available option. It's an established fact that JNA (used by all three
-alternative libraries on JDK <16) introduces more overhead when calling native
-code than JNI does.
-
-In order to provide a benchmark to see how much of a difference the different
-native interfaces make, we can use
-[criterium](https://github.com/hugoduncan/criterium) to benchmark each.
-[GLFW](https://www.glfw.org)'s
-[`glfwGetTime`](https://www.glfw.org/docs/latest/group__input.html#gaa6cf4e7a77158a3b8fd00328b1720a4a)
-function will be used for the test as it performs a simple operation, and is
-conveniently already wrapped in JNI by the excellent
-[LWJGL](https://www.lwjgl.org/) library.
-
-The following benchmarks were run on a Lenovo Thinkpad with an Intel i7-10610U
-running Manjaro Linux, using Clojure 1.10.3 on Java 17.
-
-#### JNI
-The baseline for performance is the JNI. Using LWJGL it's relatively simple to
-benchmark. The following Clojure CLI command will start a repl with LWJGL and
-criterium loaded.
-
-```sh
-$ clj -Sdeps '{:deps {org.lwjgl/lwjgl {:mvn/version "3.2.3"}
-                      org.lwjgl/lwjgl-glfw {:mvn/version "3.2.3"}
-                      org.lwjgl/lwjgl$natives-linux {:mvn/version "3.2.3"}
-                      org.lwjgl/lwjgl-glfw$natives-linux {:mvn/version "3.2.3"}
-                      criterium/criterium {:mvn/version "0.4.6"}}}'
-```
-
-Then from the repl
-
-```clojure
-user=> (import 'org.lwjgl.glfw.GLFW)
-org.lwjgl.glfw.GLFW
-user=> (require '[criterium.core :as bench])
-nil
-user=> (GLFW/glfwInit)
-true
-user=> (bench/bench (GLFW/glfwGetTime) :verbose)
-amd64 Linux 5.10.68-1-MANJARO 8 cpu(s)
-OpenJDK 64-Bit Server VM 17+35-2724
-Runtime arguments: -Dclojure.basis=/home/jsusk/.clojure/.cpcache/2667074721.basis
-Evaluation count : 1613349900 in 60 samples of 26889165 calls.
-      Execution time sample mean : 32.698446 ns
-             Execution time mean : 32.697811 ns
-Execution time sample std-deviation : 1.274600 ns
-    Execution time std-deviation : 1.276437 ns
-   Execution time lower quantile : 30.750813 ns ( 2.5%)
-   Execution time upper quantile : 33.757662 ns (97.5%)
-                   Overhead used : 6.400704 ns
-nil
-```
-
-GLFW requires that we initialize it before calling the `glfwGetTime` function.
-Besides that this is a simple interop call which directly maps to the native
-function.
-
-This gives us a basis of 32.7 ns +/-1.3 ns. All other libraries will be
-evaluated relative to this result.
-
-To ensure fairness, we'll also get that overhead value to be used in further
-tests.
-
-```clojure
-user=> bench/estimated-overhead-cache
-6.400703613065185E-9
-```
-
-#### Coffi
-The dependencies when using coffi are simpler, but it also requires some JVM
-options to support the foreign access api.
-
-```sh
-$ clj -Sdeps '{:deps {org.suskalo/coffi {:mvn/version "0.1.205"}
-                      criterium/criterium {:mvn/version "0.4.6"}}}' \
-      -J--add-modules=jdk.incubator.foreign \
-      -J--enable-native-access=ALL-UNNAMED
-```
-
-In order to ensure fair comparisons, we're going to use the same overhead value
-on each run, so before we do the benchmark we'll set it to the observed value
-from last time.
-
-```clojure
-user=> (require '[criterium.core :as bench])
-nil
-user=> (alter-var-root #'bench/estimated-overhead-cache (constantly 6.400703613065185E-9))
-6.400703613065185E-9
-user=> (require '[coffi.ffi :as ffi])
-nil
-user=> (require '[coffi.mem :as mem])
-nil
-user=> (ffi/load-system-library "glfw")
-nil
-user=> ((ffi/cfn "glfwInit" [] ::mem/int))
-1
-user=> (let [f (ffi/cfn "glfwGetTime" [] ::mem/double)]
-         (bench/bench (f) :verbose))
-amd64 Linux 5.10.68-1-MANJARO 8 cpu(s)
-OpenJDK 64-Bit Server VM 17+35-2724
-Runtime arguments: --add-modules=jdk.incubator.foreign --enable-native-access=ALL-UNNAMED -Dclojure.basis=/home/jsusk/.clojure/.cpcache/72793624.basis
-Evaluation count : 1657995600 in 60 samples of 27633260 calls.
-      Execution time sample mean : 31.382665 ns
-             Execution time mean : 31.386493 ns
-Execution time sample std-deviation : 1.598571 ns
-    Execution time std-deviation : 1.608818 ns
-   Execution time lower quantile : 29.761194 ns ( 2.5%)
-   Execution time upper quantile : 33.228276 ns (97.5%)
-                   Overhead used : 6.400704 ns
-nil
-```
-
-This result is about 1.3 ns faster, and while that is less than the standard
-deviation of 1.6, it's quite close to it.
-
-#### Clojure-JNA
-Clojure-JNA uses the JNA library, which was designed to provide Java with an
-easy way to access native libraries, but which is known for not having the
-greatest performance. Since this is an older project, I'm also including the
-clojure dependency to ensure the correct version is used.
-
-```sh
-$ clj -Sdeps '{:deps {org.clojure/clojure {:mvn/version "1.10.3"}
-                      net.n01se/clojure-jna {:mvn/version "1.0.0"}
-                      criterium/criterium {:mvn/version "0.4.6"}}}'
-```
-
-The naive way to call the function using Clojure-JNA is to use `jna/invoke`.
-
-```clojure
-user=> (require '[criterium.core :as bench])
-nil
-user=> (alter-var-root #'bench/estimated-overhead-cache (constantly 6.400703613065185E-9))
-6.400703613065185E-9
-user=> (require '[net.n01se.clojure-jna :as jna])
-nil
-user=> (jna/invoke Integer glfw/glfwInit)
-1
-user=> (bench/bench (jna/invoke Double glfw/glfwGetTime) :verbose)
-amd64 Linux 5.10.68-1-MANJARO 8 cpu(s)
-OpenJDK 64-Bit Server VM 17+35-2724
-Runtime arguments: -Dclojure.basis=/home/jsusk/.clojure/.cpcache/3229486237.basis
-Evaluation count : 195948720 in 60 samples of 3265812 calls.
-      Execution time sample mean : 350.335614 ns
-             Execution time mean : 350.373520 ns
-Execution time sample std-deviation : 24.833070 ns
-    Execution time std-deviation : 24.755929 ns
-   Execution time lower quantile : 300.000019 ns ( 2.5%)
-   Execution time upper quantile : 365.759273 ns (97.5%)
-                   Overhead used : 6.400704 ns
-
-Found 13 outliers in 60 samples (21.6667 %)
-	low-severe	 12 (20.0000 %)
-	low-mild	 1 (1.6667 %)
- Variance from outliers : 53.4220 % Variance is severely inflated by outliers
-nil
-```
-
-As you can see, this method of calling functions is very bad for performance,
-with call overhead dominating function runtime by an order of magnitude. That
-said, this isn't a completely fair comparison, nor the most realistic, because
-this way of calling functions looks the function up on each invocation.
-
-To adjust for this, we'll use the `jna/to-fn` function to give a persistent
-handle to the function that we can call.
-
-```clojure
-user=> (let [f (jna/to-fn Double glfw/glfwGetTime)]
-         (bench/bench (f) :verbose))
-amd64 Linux 5.10.68-1-MANJARO 8 cpu(s)
-OpenJDK 64-Bit Server VM 17+35-2724
-Runtime arguments: -Dclojure.basis=/home/jsusk/.clojure/.cpcache/3229486237.basis
-Evaluation count : 611095020 in 60 samples of 10184917 calls.
-      Execution time sample mean : 104.623634 ns
-             Execution time mean : 104.638406 ns
-Execution time sample std-deviation : 7.649296 ns
-    Execution time std-deviation : 7.638963 ns
-   Execution time lower quantile : 92.446016 ns ( 2.5%)
-   Execution time upper quantile : 110.258832 ns (97.5%)
-                   Overhead used : 6.400704 ns
-nil
-```
-
-This is much better, but is still about 3x slower than JNI, meaning the overhead
-from using JNA is still bigger than the function runtime.
-
-This performance penalty is still small in the scope of longer-running
-functions, and so may not be a concern for your application, but it is something
-to be aware of.
-
-#### tech.jna
-The tech.jna library is similar in scope to Clojure-JNA, however was written to
-fit into an ecosystem of libraries meant for array-based programming for machine
-learning and data science.
-
-```sh
-$ clj -Sdeps '{:deps {techascent/tech.jna {:mvn/version "4.05"}
-                      criterium/criterium {:mvn/version "0.4.6"}}}'
-```
-
-This library is also quite simple to use, the only slightly odd thing I'm doing
-here is to dereference the var outside the benchmark in order to ensure it's an
-apples-to-apples comparison. We don't want var dereference time mucking up our
-benchmark.
-
-```clojure
-user=> (require '[criterium.core :as bench])
-nil
-user=> (alter-var-root #'bench/estimated-overhead-cache (constantly 6.400703613065185E-9))
-6.400703613065185E-9
-user=> (require '[tech.v3.jna :as jna])
-nil
-user=> (jna/def-jna-fn "glfw" glfwInit "initialize glfw" Integer)
-#'user/glfwInit
-user=> (glfwInit)
-Oct 09, 2021 10:30:50 AM clojure.tools.logging$eval1122$fn__1125 invoke
-INFO: Library glfw found at [:system "glfw"]
-1
-user=> (jna/def-jna-fn "glfw" glfwGetTime "gets the time as a double since init" Double)
-#'user/glfwGetTime
-user=> (let [f @#'glfwGetTime]
-         (bench/bench (f) :verbose))
-amd64 Linux 5.10.68-1-MANJARO 8 cpu(s)
-OpenJDK 64-Bit Server VM 17+35-2724
-Runtime arguments: -Dclojure.basis=/home/jsusk/.clojure/.cpcache/2910209237.basis
-Evaluation count : 323281680 in 60 samples of 5388028 calls.
-      Execution time sample mean : 203.976803 ns
-             Execution time mean : 203.818712 ns
-Execution time sample std-deviation : 14.557312 ns
-    Execution time std-deviation : 14.614080 ns
-   Execution time lower quantile : 179.732593 ns ( 2.5%)
-   Execution time upper quantile : 213.929374 ns (97.5%)
-                   Overhead used : 6.400704 ns
-nil
-```
-
-This version is even slower than Clojure-JNA. I'm unsure where this overhead is
-coming from, but I'll admit that I haven't looked at their implementations very
-closely.
-
-#### dtype-next
-The library dtype-next replaced tech.jna in the toolkit of the group working on
-machine learning and array-based programming, and it includes support for
-composite data types including structs, as well as primitive functions and
-callbacks.
-
-In addition, dtype-next has two different ffi backends. First is JNA, which is
-usable on any JDK version, and is what we'll use for the first benchmark. Second
-is the Java 16 version of Project Panama, which will be shown next.
-
-In order to use the dtype-next ffi with the JNA backend, the JNA library has to
-be included in the dependencies.
-
-```sh
-$ clj -Sdeps '{:deps {cnuernber/dtype-next {:mvn/version "8.032"}
-                      net.java.dev.jna/jna {:mvn/version "5.8.0"}
-                      criterium/criterium {:mvn/version "0.4.6"}}}'
-```
-
-The dtype-next library also requires some more ceremony around declaring native
-functions. One advantage this has is that multiple symbols with the same name
-can be loaded from different shared libraries, but it also does increase
-friction when defining native wrappers.
-
-Some easier ways to define native wrappers are provided than what is seen here,
-but they share some disadvantages in documentation over the core methods
-provided in coffi, although they are comparable to the data model provided in
-coffi.
-
-```clojure
-user=> (require '[criterium.core :as bench])
-nil
-user=> (alter-var-root #'bench/estimated-overhead-cache (constantly 6.400703613065185E-9))
-6.400703613065185E-9
-user=> (require '[tech.v3.datatype.ffi :as dt-ffi])
-nil
-user=> (def fn-defs {:glfwInit {:rettype :int32} :glfwGetTime {:rettype :float64}})
-#'user/fn-defs
-user=> (def library-def (dt-ffi/define-library fn-defs))
-#'user/library-def
-user=> (def library-instance (dt-ffi/instantiate-library library-def "/usr/lib/libglfw.so"))
-#'user/library-instance
-user=> (def init (:glfwInit @library-instance))
-#'user/init
-user=> (init)
-1
-user=> (let [f (:glfwGetTime @library-instance)]
-         (bench/bench (f) :verbose))
-amd64 Linux 5.10.68-1-MANJARO 8 cpu(s)
-OpenJDK 64-Bit Server VM 17+35-2724
-Runtime arguments: -Dclojure.basis=/home/jsusk/.clojure/.cpcache/643862289.basis
-Evaluation count : 710822100 in 60 samples of 11847035 calls.
-      Execution time sample mean : 90.900112 ns
-             Execution time mean : 90.919917 ns
-Execution time sample std-deviation : 6.463312 ns
-    Execution time std-deviation : 6.470108 ns
-   Execution time lower quantile : 79.817126 ns ( 2.5%)
-   Execution time upper quantile : 95.454652 ns (97.5%)
-                   Overhead used : 6.400704 ns
-nil
-```
-
-This version of JNA usage is significantly faster than either of the other JNA
-libraries, but is still substantially slower than using JNI or coffi.
-
-In addition to the JNA backend, dtype-next has a Java 16-specific backend that
-uses an older version of Panama. This version requires similar setup to coffi in
-order to run.
-
-```sh
-$ clj -Sdeps '{:deps {cnuernber/dtype-next {:mvn/version "8.032"}
-                      criterium/criterium {:mvn/version "0.4.6"}}}' \
-      -J--add-modules=jdk.incubator.foreign \
-      -J-Dforeign.restricted=permit \
-      -J--add-opens=java.base/java.lang=ALL-UNNAMED \
-      -J-Djava.library.path=/usr/lib/x86_64-linux-gnu
-```
-
-The actual code to run the benchmark is identical to the last example, but is
-reproduced here for completeness.
-
-```clojure
-user=> (require '[criterium.core :as bench])
-nil
-user=> (alter-var-root #'bench/estimated-overhead-cache (constantly 6.400703613065185E-9))
-6.400703613065185E-9
-user=> (require '[tech.v3.datatype.ffi :as dt-ffi])
-nil
-user=> (def fn-defs {:glfwInit {:rettype :int32} :glfwGetTime {:rettype :float64}})
-#'user/fn-defs
-user=> (def library-def (dt-ffi/define-library fn-defs))
-#'user/library-def
-user=> (def library-instance (dt-ffi/instantiate-library library-def "/usr/lib/libglfw.so"))
-#'user/library-instance
-user=> (def init (:glfwInit @library-instance))
-#'user/init
-user=> (init)
-1
-user=> (let [f (:glfwGetTime @library-instance)]
-         (bench/bench (f) :verbose))
-amd64 Linux 5.10.68-1-MANJARO 8 cpu(s)
-OpenJDK 64-Bit Server VM 16.0.2+7
-Runtime arguments: --add-modules=jdk.incubator.foreign -Dforeign.restricted=permit --add-opens=java.base/java.lang=ALL-UNNAMED -Djava.library.path=/usr/lib/x86_64-linux-gnu -Dclojure.basis=/home/jsusk/.clojure/.cpcache/2337051659.basis
-Evaluation count : 1588513080 in 60 samples of 26475218 calls.
-      Execution time sample mean : 58.732468 ns
-             Execution time mean : 58.647361 ns
-Execution time sample std-deviation : 9.732389 ns
-    Execution time std-deviation : 9.791738 ns
-   Execution time lower quantile : 31.318115 ns ( 2.5%)
-   Execution time upper quantile : 65.449222 ns (97.5%)
-                   Overhead used : 6.400704 ns
-
-Found 14 outliers in 60 samples (23.3333 %)
-	low-severe	 8 (13.3333 %)
-	low-mild	 4 (6.6667 %)
-	high-mild	 2 (3.3333 %)
- Variance from outliers : 87.6044 % Variance is severely inflated by outliers
-nil
-```
-
-Not reproduced here, but notable for comparison, in my testing Java 16's version
-of the JNI version performed about the same.
-
-This is significantly faster than the JNA version of dtype-next, but it is still
-slower than modern Panama. This is likely to simply be a result of optimizations
-and changes to the Panama API, and when dtype-next is updated to use the Java 17
-version of Panama I expect it will perform in line with coffi, but this
-benchmark will be reproduced when this happens. Still, this shows that as it
-stands, coffi is the fastest FFI available to Clojure developers.
+There is also a [third party round up](https://docs.google.com/spreadsheets/d/1ViLHNUgrO2osh2AH0h7MaCaXz8g0UpLbyWojY5f10kk/edit?gid=332155605#gid=332155605)
+of FFI options for Clojure.
 
 ## Known Issues
 The project author is aware of these issues and plans to fix them in a future
@@ -1135,14 +139,14 @@ release:
 These features are planned for future releases.
 
 - Support for va_args type
-- Header parsing tool for generating a data model?
+- Header parsing tool for generating a data model? (maybe just work with [clong](https://github.com/phronmophobic/clong)?)
 - Generic type aliases
 - Unsigned integer types
 - Record-based struct types
 - Helper macro for out arguments
 - Improve error messages from defcfn macro
 - Mapped memory
-- Helper macros for custom serde implementations for composite data types
+- Helper macros for custom serde implementations for composite data types (this is in progress [for structs](https://github.com/IGJoshua/coffi/issues/12)!)
 
 ## License
 

From 4b490bf24f190f7282fa07e8d839898c42242328 Mon Sep 17 00:00:00 2001
From: Joshua Suskalo <joshua@suskalo.org>
Date: Fri, 4 Oct 2024 16:11:21 -0400
Subject: [PATCH 3/6] Add Getting Started article

---
 README.md                           |   6 +-
 deps.edn                            |   1 +
 docs/01-Getting-Started.html        | 147 +++++++++++++
 docs/articles/01-Getting-Started.md | 309 ++++++++++++++++++++++++++++
 docs/coffi.ffi.html                 |  42 ++--
 docs/coffi.layout.html              |   4 +-
 docs/coffi.mem.html                 | 148 ++++++-------
 docs/index.html                     |   2 +-
 8 files changed, 560 insertions(+), 99 deletions(-)
 create mode 100644 docs/01-Getting-Started.html
 create mode 100644 docs/articles/01-Getting-Started.md

diff --git a/README.md b/README.md
index 23831ac..c50f506 100644
--- a/README.md
+++ b/README.md
@@ -11,6 +11,10 @@ doesn't remove the ability to write systems which minimize the cost of
 marshaling data and optimize for performance, to make use of the low-level
 access the FF&M API gives us.
 
+- [Getting Started](igjoshua.github.io/coffi/01-Getting-Started.html)
+- [API Documentation](igjoshua.github.io/coffi/)
+- [Recent Changes](CHANGELOG.md)
+
 ## Installation
 This library is available on Clojars, or as a git dependency. Add one of the
 following entries to the `:deps` key of your `deps.edn`:
@@ -37,7 +41,7 @@ the following JVM arguments to your application.
 ```
 
 You can specify JVM arguments in a particular invocation of the Clojure CLI with
-the -J flag like so:
+the `-J` flag like so:
 
 ``` sh
 clj -J--enable-native-access=ALL-UNNAMED
diff --git a/deps.edn b/deps.edn
index 843775d..1aed6e4 100644
--- a/deps.edn
+++ b/deps.edn
@@ -29,6 +29,7 @@
                       :version "v1.0.486"
                       :description "A Foreign Function Interface in Clojure for JDK 22+."
                       :source-paths  ["src/clj"]
+                      :doc-paths ["docs/articles"]
                       :output-path "docs"
                       :source-uri "https://github.com/IGJoshua/coffi/blob/{git-commit}/{filepath}#L{line}"
                       :metadata {:doc/format :markdown}}}
diff --git a/docs/01-Getting-Started.html b/docs/01-Getting-Started.html
new file mode 100644
index 0000000..fa78e5d
--- /dev/null
+++ b/docs/01-Getting-Started.html
@@ -0,0 +1,147 @@
+<!DOCTYPE html PUBLIC ""
+    "">
+<html><head><meta charset="UTF-8" /><title>Getting Started</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#getting-started" id="getting-started"></a>Getting Started</h1>
+<h2><a href="#installation" id="installation"></a>Installation</h2>
+<p>This library is available on Clojars. Add one of the following entries to the <code>:deps</code> key of your <code>deps.edn</code>:</p>
+<pre><code class="language-clojure">org.suskalo/coffi {:mvn/version "x.y.z"}
+io.github.IGJoshua/coffi {:git/tag "x.y.z" :git/sha "abcdef0"}
+</code></pre>
+<p>See GitHub for the <a href="https://github.com/IGJoshua/coffi/releases">latest releases</a>.</p>
+<p>If you use this library as a git dependency, you will need to prepare the library.</p>
+<pre><code class="language-sh">$ clj -X:deps prep
+</code></pre>
+<p>Coffi requires usage of the package <code>java.lang.foreign</code>, and most of the operations are considered unsafe by the JDK, and are therefore unavailable to your code without passing some command line flags. In order to use coffi, add the following JVM arguments to your application.</p>
+<pre><code class="language-sh">--enable-native-access=ALL-UNNAMED
+</code></pre>
+<p>You can specify JVM arguments in a particular invocation of the Clojure CLI with the -J flag like so:</p>
+<pre><code class="language-sh">clj -J--enable-native-access=ALL-UNNAMED
+</code></pre>
+<p>You can also specify them in an alias in your <code>deps.edn</code> file under the <code>:jvm-opts</code> key (see the next example) and then invoking the CLI with that alias using <code>-M</code>, <code>-A</code>, or <code>-X</code>.</p>
+<pre><code class="language-clojure">{:aliases {:dev {:jvm-opts ["--enable-native-access=ALL-UNNAMED"]}}}
+</code></pre>
+<p>Other build tools should provide similar functionality if you check their documentation.</p>
+<p>When creating an executable jar file, you can avoid the need to pass this argument by adding the manifest attribute <code>Enable-Native-Access: ALL-UNNAMED</code> to your jar.</p>
+<h2><a href="#basic-usage" id="basic-usage"></a>Basic Usage</h2>
+<p>There are two major components to coffi and interacting with native code: manipulating off-heap memory, and loading native code for use with Clojure.</p>
+<p>In the simplest cases, the native functions you call will work exclusively with built-in types, for example the function <code>strlen</code> from libc.</p>
+<pre><code class="language-clojure">(require '[coffi.mem :as mem :refer [defalias]])
+(require '[coffi.ffi :as ffi :refer [defcfn]])
+
+(defcfn strlen
+  "Given a string, measures its length in bytes."
+  strlen [::mem/c-string] ::mem/long)
+
+(strlen "hello")
+;; =&gt; 5
+</code></pre>
+<p>The first argument to <code>defcfn</code> is the name of the Clojure var that will hold the native function reference, followed by an optional docstring and attribute map, then the C function identifier, including the name of the native symbol, a vector of argument types, and the return type.</p>
+<p>If you wish to use a native function as an anonymous function, it can be done with the <code>cfn</code> function.</p>
+<pre><code class="language-clojure">((ffi/cfn "strlen" [::mem/c-string] ::mem/long) "hello")
+;; =&gt; 5
+</code></pre>
+<p>If you want to use functions from libraries other than libc, then you’ll need to load them. Two functions are provided for this, <code>load-system-library</code>, and <code>load-library</code>. <code>load-system-library</code> takes a string which represents the name of a library that should be loaded via system lookup.</p>
+<pre><code class="language-clojure">(ffi/load-system-library "z")
+</code></pre>
+<p>This will load libz from the appropriate place on the user’s load path.</p>
+<p>Alternatively, <code>load-library</code> takes a file path to a dynamically loaded library.</p>
+<pre><code class="language-clojure">(ffi/load-library "lib/libz.so")
+</code></pre>
+<p>This will load libz from the lib subdirectory of the current working directory. As you can see this requires the entire filename, including platform-specific file extensions.</p>
+<p>If a library is attempted to be loaded but doesn’t exist or otherwise can’t be loaded, an exception is thrown. This can be convenient as any namespace with a <code>load-library</code> call at the top level cannot be required without the library being able to be loaded.</p>
+<h3><a href="#primitive-types" id="primitive-types"></a>Primitive Types</h3>
+<p>Coffi defines a basic set of primitive types: - byte - short - int - long - char - float - double - pointer</p>
+<p>Each of these types maps to their C counterpart. Values of any of these primitive types except for <code>pointer</code> will be cast with their corresponding Clojure function when they are passed as arguments to native functions. Additionally, the <code>c-string</code> type is defined, although it is not primitive.</p>
+<h3><a href="#composite-types" id="composite-types"></a>Composite Types</h3>
+<p>In addition, some composite types are also defined in coffi, including struct and union types (unions will be discussed with serialization and deserialization). For an example C struct and function:</p>
+<pre><code class="language-c">typedef struct point {
+    float x;
+    float y;
+} Point;
+
+Point zero(void) {
+    Point res = {};
+
+    res.x = 0.0;
+    res.y = 0.0;
+
+    return res;
+}
+</code></pre>
+<p>The corresponding coffi definition is like so:</p>
+<pre><code class="language-clojure">(defcfn zero-point
+  "zero" [] [::mem/struct [[:x ::mem/float] [:y ::mem/float]]])
+
+(zero-point)
+;; =&gt; {:x 0.0,
+;;     :y 0.0}
+</code></pre>
+<p>Writing out struct definitions like this every time would get tedious, so the macro <code>defalias</code> is used to define a struct alias.</p>
+<pre><code class="language-clojure">(defalias ::point
+  [::mem/struct
+   [[:x ::mem/float]
+    [:y ::mem/float]]])
+
+(defcfn zero-point
+  "zero" [] ::point)
+</code></pre>
+<p>Struct definitions do not include any padding by default. Functions for transforming struct types to include padding conforming to various standards can be found in <code>coffi.layout</code>.</p>
+<pre><code class="language-clojure">(require '[coffi.layout :as layout])
+
+(defalias ::needs-padding
+  (layout/with-c-layout
+   [::mem/struct
+    [[:a ::mem/char]
+     [:x ::mem/float]]]))
+
+(mem/size-of ::needs-padding)
+;; =&gt; 8
+
+(mem/align-of ::needs-padding)
+;; =&gt; 4
+</code></pre>
+<p>Values deserialized with types produced from layout functions may include an extra <code>:coffi.layout/padding</code> key with a nil value.</p>
+<p>A limitation of the <code>defcfn</code> macro in its current form is that types provided to it must be provided in a literal form, not as an expression that evaluates to a type. This means that if you wish to use a layout function on a struct you must define an alias for it before the type can be used as a type in <code>defcfn</code>.</p>
+<p>In cases where a pointer to some data is required to pass as an argument to a native function, but doesn’t need to be read back in, the <code>pointer</code> primitive type can take a type argument.</p>
+<pre><code class="language-clojure">[::mem/pointer ::mem/int]
+</code></pre>
+<p>Arrays are also supported via a type argument. Keep in mind that they are the array itself, and not a pointer to the array like you might see in certain cases in C.</p>
+<pre><code class="language-clojure">[::mem/array ::mem/int 3]
+</code></pre>
+<h3><a href="#callbacks" id="callbacks"></a>Callbacks</h3>
+<p>In addition to these composite types, there is also support for Clojure functions.</p>
+<pre><code class="language-clojure">[::ffi/fn [::mem/c-string] ::mem/int]
+</code></pre>
+<p>Be aware though that if an exception is thrown out of a callback that is called from C, the JVM will crash. The resulting crash log should include the exception type and message in the registers section, but it’s important to be aware of all the same. Ideally you should test your callbacks before actually passing them to native code.</p>
+<p>When writing a wrapper library for a C library, it may be a good choice to wrap all passed Clojure functions in an additional function which catches all throwables, potentially notifies the user in some manner (e.g. logging), and returns a default value. This is on the wrapper library’s developer to decide when and where this is appropriate, as in some cases no reasonable default return value can be determined and it is most sensible to simply crash the JVM. This is the reason that coffi defaults to this behavior, as in the author’s opinion it is better to fail hard and fast rather than to attempt to produce a default and cause unexpected behavior later.</p>
+<p>Another important thing to keep in mind is the expected lifetime of the function that you pass to native code. For example it is perfectly fine to pass an anonymous function to a native function if the callback will never be called again once the native function returns. If however it saves the callback for later use the JVM may collect it prematurely, causing a crash when the callback is later called by native code.</p>
+<h3><a href="#variadic-functions" id="variadic-functions"></a>Variadic Functions</h3>
+<p>Some native functions can take any number of arguments, and in these cases coffi provides <code>vacfn-factory</code> (for “varargs C function factory”).</p>
+<pre><code class="language-clojure">(def printf-factory (ffi/vacfn-factory "printf" [::mem/c-string] ::mem/int))
+</code></pre>
+<p>This returns a function of the types of the rest of the arguments which itself returns a native function wrapper.</p>
+<pre><code class="language-clojure">(def print-int (printf-factory ::mem/int))
+
+(print-int "Some integer: %d\n" 5)
+;; Some integer: 5
+</code></pre>
+<p>At the moment there is no equivalent to <code>defcfn</code> for varargs functions.</p>
+<p>Some native functions that are variadic use the type <code>va_list</code> to make it easier for other languages to call them in their FFI. At the time of writing, coffi does not support va-list, however it is a planned feature.</p>
+<h3><a href="#global-variables" id="global-variables"></a>Global Variables</h3>
+<p>Some libraries include global variables or constants accessible through symbols. To start with, constant values stored in symbols can be fetched with <code>const</code>, or the parallel macro <code>defconst</code></p>
+<pre><code class="language-clojure">(def some-const (ffi/const "some_const" ::mem/int))
+(ffi/defconst some-const "some_const" ::mem/int)
+</code></pre>
+<p>This value is fetched once when you call <code>const</code> and is turned into a Clojure value. If you need to refer to a global variable, then <code>static-variable</code> (or parallel <code>defvar</code>) can be used to create a reference to the native value.</p>
+<pre><code class="language-clojure">(def some-var (ffi/static-variable "some_var" ::mem/int))
+(ffi/defvar some-var "some_var" ::mem/int)
+</code></pre>
+<p>This variable is an <code>IDeref</code>. Each time you dereference it, the value will be deserialized from the native memory and returned. Additional functions are provided for mutating the variable.</p>
+<pre><code class="language-clojure">(ffi/freset! some-var 5)
+;; =&gt; 5
+@some-var
+;; =&gt; 5
+</code></pre>
+<p>Be aware however that there is no synchronization on these types. The value being read is not read atomically, so you may see an inconsistent state if the value is being mutated on another thread.</p>
+<p>A parallel function <code>fswap!</code> is also provided, but it does not provide any atomic semantics either.</p>
+<p>The memory that backs the static variable can be fetched with the function <code>static-variable-segment</code>, which can be used to pass a pointer to the static variable to native functions that require it.</p>
+</div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/articles/01-Getting-Started.md b/docs/articles/01-Getting-Started.md
new file mode 100644
index 0000000..f190cc2
--- /dev/null
+++ b/docs/articles/01-Getting-Started.md
@@ -0,0 +1,309 @@
+# Getting Started
+
+## Installation
+This library is available on Clojars. Add one of the following entries to the
+`:deps` key of your `deps.edn`:
+
+```clojure
+org.suskalo/coffi {:mvn/version "x.y.z"}
+io.github.IGJoshua/coffi {:git/tag "x.y.z" :git/sha "abcdef0"}
+```
+
+See GitHub for the [latest releases](https://github.com/IGJoshua/coffi/releases).
+
+If you use this library as a git dependency, you will need to prepare the
+library.
+
+```sh
+$ clj -X:deps prep
+```
+
+Coffi requires usage of the package `java.lang.foreign`, and most of the
+operations are considered unsafe by the JDK, and are therefore unavailable to
+your code without passing some command line flags. In order to use coffi, add
+the following JVM arguments to your application.
+
+```sh
+--enable-native-access=ALL-UNNAMED
+```
+
+You can specify JVM arguments in a particular invocation of the Clojure CLI with
+the -J flag like so:
+
+``` sh
+clj -J--enable-native-access=ALL-UNNAMED
+```
+
+You can also specify them in an alias in your `deps.edn` file under the
+`:jvm-opts` key (see the next example) and then invoking the CLI with that alias
+using `-M`, `-A`, or `-X`.
+
+``` clojure
+{:aliases {:dev {:jvm-opts ["--enable-native-access=ALL-UNNAMED"]}}}
+```
+
+Other build tools should provide similar functionality if you check their
+documentation.
+
+When creating an executable jar file, you can avoid the need to pass this
+argument by adding the manifest attribute `Enable-Native-Access: ALL-UNNAMED` to
+your jar.
+
+## Basic Usage
+There are two major components to coffi and interacting with native code:
+manipulating off-heap memory, and loading native code for use with Clojure.
+
+In the simplest cases, the native functions you call will work exclusively with
+built-in types, for example the function `strlen` from libc.
+
+```clojure
+(require '[coffi.mem :as mem :refer [defalias]])
+(require '[coffi.ffi :as ffi :refer [defcfn]])
+
+(defcfn strlen
+  "Given a string, measures its length in bytes."
+  strlen [::mem/c-string] ::mem/long)
+
+(strlen "hello")
+;; => 5
+```
+
+The first argument to `defcfn` is the name of the Clojure var that will hold the
+native function reference, followed by an optional docstring and attribute map,
+then the C function identifier, including the name of the native symbol, a
+vector of argument types, and the return type.
+
+If you wish to use a native function as an anonymous function, it can be done
+with the `cfn` function.
+
+```clojure
+((ffi/cfn "strlen" [::mem/c-string] ::mem/long) "hello")
+;; => 5
+```
+
+If you want to use functions from libraries other than libc, then you'll need to
+load them. Two functions are provided for this, `load-system-library`, and
+`load-library`. `load-system-library` takes a string which represents the name
+of a library that should be loaded via system lookup.
+
+```clojure
+(ffi/load-system-library "z")
+```
+
+This will load libz from the appropriate place on the user's load path.
+
+Alternatively, `load-library` takes a file path to a dynamically loaded library.
+
+```clojure
+(ffi/load-library "lib/libz.so")
+```
+
+This will load libz from the lib subdirectory of the current working directory.
+As you can see this requires the entire filename, including platform-specific
+file extensions.
+
+If a library is attempted to be loaded but doesn't exist or otherwise can't be
+loaded, an exception is thrown. This can be convenient as any namespace with a
+`load-library` call at the top level cannot be required without the library
+being able to be loaded.
+
+### Primitive Types
+Coffi defines a basic set of primitive types:
+- byte
+- short
+- int
+- long
+- char
+- float
+- double
+- pointer
+
+Each of these types maps to their C counterpart. Values of any of these
+primitive types except for `pointer` will be cast with their corresponding
+Clojure function when they are passed as arguments to native functions.
+Additionally, the `c-string` type is defined, although it is not primitive.
+
+### Composite Types
+In addition, some composite types are also defined in coffi, including struct
+and union types (unions will be discussed with serialization and
+deserialization). For an example C struct and function:
+
+```c
+typedef struct point {
+    float x;
+    float y;
+} Point;
+
+Point zero(void) {
+    Point res = {};
+
+    res.x = 0.0;
+    res.y = 0.0;
+
+    return res;
+}
+```
+
+The corresponding coffi definition is like so:
+
+```clojure
+(defcfn zero-point
+  "zero" [] [::mem/struct [[:x ::mem/float] [:y ::mem/float]]])
+
+(zero-point)
+;; => {:x 0.0,
+;;     :y 0.0}
+```
+
+Writing out struct definitions like this every time would get tedious, so the
+macro `defalias` is used to define a struct alias.
+
+```clojure
+(defalias ::point
+  [::mem/struct
+   [[:x ::mem/float]
+    [:y ::mem/float]]])
+
+(defcfn zero-point
+  "zero" [] ::point)
+```
+
+Struct definitions do not include any padding by default. Functions for
+transforming struct types to include padding conforming to various standards can
+be found in `coffi.layout`.
+
+``` clojure
+(require '[coffi.layout :as layout])
+
+(defalias ::needs-padding
+  (layout/with-c-layout
+   [::mem/struct
+    [[:a ::mem/char]
+     [:x ::mem/float]]]))
+
+(mem/size-of ::needs-padding)
+;; => 8
+
+(mem/align-of ::needs-padding)
+;; => 4
+```
+
+Values deserialized with types produced from layout functions may include an
+extra `:coffi.layout/padding` key with a nil value.
+
+A limitation of the `defcfn` macro in its current form is that types provided to
+it must be provided in a literal form, not as an expression that evaluates to a
+type. This means that if you wish to use a layout function on a struct you must
+define an alias for it before the type can be used as a type in `defcfn`.
+
+In cases where a pointer to some data is required to pass as an argument to a
+native function, but doesn't need to be read back in, the `pointer` primitive
+type can take a type argument.
+
+```clojure
+[::mem/pointer ::mem/int]
+```
+
+Arrays are also supported via a type argument. Keep in mind that they are the
+array itself, and not a pointer to the array like you might see in certain cases
+in C.
+
+```clojure
+[::mem/array ::mem/int 3]
+```
+
+### Callbacks
+In addition to these composite types, there is also support for Clojure
+functions.
+
+```clojure
+[::ffi/fn [::mem/c-string] ::mem/int]
+```
+
+Be aware though that if an exception is thrown out of a callback that is called
+from C, the JVM will crash. The resulting crash log should include the exception
+type and message in the registers section, but it's important to be aware of all
+the same. Ideally you should test your callbacks before actually passing them to
+native code.
+
+When writing a wrapper library for a C library, it may be a good choice to wrap
+all passed Clojure functions in an additional function which catches all
+throwables, potentially notifies the user in some manner (e.g. logging), and
+returns a default value. This is on the wrapper library's developer to decide
+when and where this is appropriate, as in some cases no reasonable default
+return value can be determined and it is most sensible to simply crash the JVM.
+This is the reason that coffi defaults to this behavior, as in the author's
+opinion it is better to fail hard and fast rather than to attempt to produce a
+default and cause unexpected behavior later.
+
+Another important thing to keep in mind is the expected lifetime of the function
+that you pass to native code. For example it is perfectly fine to pass an
+anonymous function to a native function if the callback will never be called
+again once the native function returns. If however it saves the callback for
+later use the JVM may collect it prematurely, causing a crash when the callback
+is later called by native code.
+
+### Variadic Functions
+Some native functions can take any number of arguments, and in these cases coffi
+provides `vacfn-factory` (for "varargs C function factory").
+
+```clojure
+(def printf-factory (ffi/vacfn-factory "printf" [::mem/c-string] ::mem/int))
+```
+
+This returns a function of the types of the rest of the arguments which itself
+returns a native function wrapper.
+
+```clojure
+(def print-int (printf-factory ::mem/int))
+
+(print-int "Some integer: %d\n" 5)
+;; Some integer: 5
+```
+
+At the moment there is no equivalent to `defcfn` for varargs functions.
+
+Some native functions that are variadic use the type `va_list` to make it easier
+for other languages to call them in their FFI. At the time of writing, coffi
+does not support va-list, however it is a planned feature.
+
+### Global Variables
+Some libraries include global variables or constants accessible through symbols.
+To start with, constant values stored in symbols can be fetched with `const`, or
+the parallel macro `defconst`
+
+```clojure
+(def some-const (ffi/const "some_const" ::mem/int))
+(ffi/defconst some-const "some_const" ::mem/int)
+```
+
+This value is fetched once when you call `const` and is turned into a Clojure
+value. If you need to refer to a global variable, then `static-variable` (or
+parallel `defvar`) can be used to create a reference to the native value.
+
+```clojure
+(def some-var (ffi/static-variable "some_var" ::mem/int))
+(ffi/defvar some-var "some_var" ::mem/int)
+```
+
+This variable is an `IDeref`. Each time you dereference it, the value will be
+deserialized from the native memory and returned. Additional functions are
+provided for mutating the variable.
+
+```clojure
+(ffi/freset! some-var 5)
+;; => 5
+@some-var
+;; => 5
+```
+
+Be aware however that there is no synchronization on these types. The value
+being read is not read atomically, so you may see an inconsistent state if the
+value is being mutated on another thread.
+
+A parallel function `fswap!` is also provided, but it does not provide any
+atomic semantics either.
+
+The memory that backs the static variable can be fetched with the function
+`static-variable-segment`, which can be used to pass a pointer to the static
+variable to native functions that require it.
diff --git a/docs/coffi.ffi.html b/docs/coffi.ffi.html
index c843e2a..7cc8c2c 100644
--- a/docs/coffi.ffi.html
+++ b/docs/coffi.ffi.html
@@ -1,41 +1,41 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>coffi.ffi documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch current"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="coffi.ffi.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-const"><div class="inner"><span>const</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-defcfn"><div class="inner"><span>defcfn</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-defconst"><div class="inner"><span>defconst</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-defvar"><div class="inner"><span>defvar</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-ensure-symbol"><div class="inner"><span>ensure-symbol</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-find-symbol"><div class="inner"><span>find-symbol</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-freset.21"><div class="inner"><span>freset!</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-fswap.21"><div class="inner"><span>fswap!</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-load-library"><div class="inner"><span>load-library</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-load-system-library"><div class="inner"><span>load-system-library</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-make-downcall"><div class="inner"><span>make-downcall</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-make-serde-varargs-wrapper"><div class="inner"><span>make-serde-varargs-wrapper</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-make-serde-wrapper"><div class="inner"><span>make-serde-wrapper</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-make-varargs-factory"><div class="inner"><span>make-varargs-factory</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-reify-libspec"><div class="inner"><span>reify-libspec</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-reify-symbolspec"><div class="inner"><span>reify-symbolspec</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-static-variable"><div class="inner"><span>static-variable</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-static-variable-segment"><div class="inner"><span>static-variable-segment</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-vacfn-factory"><div class="inner"><span>vacfn-factory</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">coffi.ffi</h1><div class="doc"><div class="markdown"><p>Functions for creating handles to native functions and loading native libraries.</p>
+<html><head><meta charset="UTF-8" /><title>coffi.ffi documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch current"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="coffi.ffi.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-const"><div class="inner"><span>const</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-defcfn"><div class="inner"><span>defcfn</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-defconst"><div class="inner"><span>defconst</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-defvar"><div class="inner"><span>defvar</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-ensure-symbol"><div class="inner"><span>ensure-symbol</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-find-symbol"><div class="inner"><span>find-symbol</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-freset.21"><div class="inner"><span>freset!</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-fswap.21"><div class="inner"><span>fswap!</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-load-library"><div class="inner"><span>load-library</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-load-system-library"><div class="inner"><span>load-system-library</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-make-downcall"><div class="inner"><span>make-downcall</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-make-serde-varargs-wrapper"><div class="inner"><span>make-serde-varargs-wrapper</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-make-serde-wrapper"><div class="inner"><span>make-serde-wrapper</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-make-varargs-factory"><div class="inner"><span>make-varargs-factory</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-reify-libspec"><div class="inner"><span>reify-libspec</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-reify-symbolspec"><div class="inner"><span>reify-symbolspec</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-static-variable"><div class="inner"><span>static-variable</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-static-variable-segment"><div class="inner"><span>static-variable-segment</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-vacfn-factory"><div class="inner"><span>vacfn-factory</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">coffi.ffi</h1><div class="doc"><div class="markdown"><p>Functions for creating handles to native functions and loading native libraries.</p>
 </div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn symbol args ret)</code></div><div class="doc"><div class="markdown"><p>Constructs a Clojure function to call the native function referenced by <code>symbol</code>.</p>
 <p>The function returned will serialize any passed arguments into the <code>args</code> types, and deserialize the return to the <code>ret</code> type.</p>
 <p>If your <code>args</code> and <code>ret</code> are constants, then it is more efficient to call <a href="coffi.ffi.html#var-make-downcall">make-downcall</a> followed by <a href="coffi.ffi.html#var-make-serde-wrapper">make-serde-wrapper</a> because the latter has an inline definition which will result in less overhead from serdes.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/ffi.clj#L438">view source</a></div></div><div class="public anchor" id="var-const"><h3>const</h3><div class="usage"><code>(const symbol-or-addr type)</code></div><div class="doc"><div class="markdown"><p>Gets the value of a constant stored in <code>symbol-or-addr</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/ffi.clj#L606">view source</a></div></div><div class="public anchor" id="var-defcfn"><h3>defcfn</h3><h4 class="type">macro</h4><div class="usage"><code>(defcfn name docstring? attr-map? symbol arg-types ret-type)</code><code>(defcfn name docstring? attr-map? symbol arg-types ret-type native-fn &amp; fn-tail)</code></div><div class="doc"><div class="markdown"><p>Defines a Clojure function which maps to a native function.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/ffi.clj#L438">view source</a></div></div><div class="public anchor" id="var-const"><h3>const</h3><div class="usage"><code>(const symbol-or-addr type)</code></div><div class="doc"><div class="markdown"><p>Gets the value of a constant stored in <code>symbol-or-addr</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/ffi.clj#L606">view source</a></div></div><div class="public anchor" id="var-defcfn"><h3>defcfn</h3><h4 class="type">macro</h4><div class="usage"><code>(defcfn name docstring? attr-map? symbol arg-types ret-type)</code><code>(defcfn name docstring? attr-map? symbol arg-types ret-type native-fn &amp; fn-tail)</code></div><div class="doc"><div class="markdown"><p>Defines a Clojure function which maps to a native function.</p>
 <p><code>name</code> is the symbol naming the resulting var. <code>symbol</code> is a symbol or string naming the library symbol to link against. <code>arg-types</code> is a vector of qualified keywords representing the argument types. <code>ret-type</code> is a single qualified keyword representing the return type. <code>fn-tail</code> is the body of the function (potentially with multiple arities) which wraps the native one. Inside the function, <code>native-fn</code> is bound to a function that will serialize its arguments, call the native function, and deserialize its return type. If any body is present, you must call this function in order to call the native code.</p>
 <p>If no <code>fn-tail</code> is provided, then the resulting function will simply serialize the arguments according to <code>arg-types</code>, call the native function, and deserialize the return value.</p>
 <p>The number of args in the <code>fn-tail</code> need not match the number of <code>arg-types</code> for the native function. It need only call the native wrapper function with the correct arguments.</p>
 <p>See <a href="coffi.mem.html#var-serialize">serialize</a>, <a href="coffi.mem.html#var-deserialize">deserialize</a>, <a href="coffi.ffi.html#var-make-downcall">make-downcall</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/ffi.clj#L780">view source</a></div></div><div class="public anchor" id="var-defconst"><h3>defconst</h3><h4 class="type">macro</h4><div class="usage"><code>(defconst symbol docstring? symbol-or-addr type)</code></div><div class="doc"><div class="markdown"><p>Defines a var named by <code>symbol</code> to be the value of the given <code>type</code> from <code>symbol-or-addr</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/ffi.clj#L617">view source</a></div></div><div class="public anchor" id="var-defvar"><h3>defvar</h3><h4 class="type">macro</h4><div class="usage"><code>(defvar symbol docstring? symbol-or-addr type)</code></div><div class="doc"><div class="markdown"><p>Defines a var named by <code>symbol</code> to be a reference to the native memory from <code>symbol-or-addr</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/ffi.clj#L683">view source</a></div></div><div class="public anchor" id="var-ensure-symbol"><h3>ensure-symbol</h3><div class="usage"><code>(ensure-symbol symbol-or-addr)</code></div><div class="doc"><div class="markdown"><p>Returns the argument if it is a <a href="null">MemorySegment</a>, otherwise calls <a href="coffi.ffi.html#var-find-symbol">find-symbol</a> on it.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/ffi.clj#L198">view source</a></div></div><div class="public anchor" id="var-find-symbol"><h3>find-symbol</h3><div class="usage"><code>(find-symbol sym)</code></div><div class="doc"><div class="markdown"><p>Gets the <a href="null">MemorySegment</a> of a symbol from the loaded libraries.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/ffi.clj#L38">view source</a></div></div><div class="public anchor" id="var-freset.21"><h3>freset!</h3><div class="usage"><code>(freset! static-var newval)</code></div><div class="doc"><div class="markdown"><p>Sets the value of <code>static-var</code> to <code>newval</code>, running it through <a href="coffi.mem.html#var-serialize">serialize</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/ffi.clj#L647">view source</a></div></div><div class="public anchor" id="var-fswap.21"><h3>fswap!</h3><div class="usage"><code>(fswap! static-var f &amp; args)</code></div><div class="doc"><div class="markdown"><p>Non-atomically runs the function <code>f</code> over the value stored in <code>static-var</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/ffi.clj#L780">view source</a></div></div><div class="public anchor" id="var-defconst"><h3>defconst</h3><h4 class="type">macro</h4><div class="usage"><code>(defconst symbol docstring? symbol-or-addr type)</code></div><div class="doc"><div class="markdown"><p>Defines a var named by <code>symbol</code> to be the value of the given <code>type</code> from <code>symbol-or-addr</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/ffi.clj#L617">view source</a></div></div><div class="public anchor" id="var-defvar"><h3>defvar</h3><h4 class="type">macro</h4><div class="usage"><code>(defvar symbol docstring? symbol-or-addr type)</code></div><div class="doc"><div class="markdown"><p>Defines a var named by <code>symbol</code> to be a reference to the native memory from <code>symbol-or-addr</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/ffi.clj#L683">view source</a></div></div><div class="public anchor" id="var-ensure-symbol"><h3>ensure-symbol</h3><div class="usage"><code>(ensure-symbol symbol-or-addr)</code></div><div class="doc"><div class="markdown"><p>Returns the argument if it is a <a href="null">MemorySegment</a>, otherwise calls <a href="coffi.ffi.html#var-find-symbol">find-symbol</a> on it.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/ffi.clj#L198">view source</a></div></div><div class="public anchor" id="var-find-symbol"><h3>find-symbol</h3><div class="usage"><code>(find-symbol sym)</code></div><div class="doc"><div class="markdown"><p>Gets the <a href="null">MemorySegment</a> of a symbol from the loaded libraries.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/ffi.clj#L38">view source</a></div></div><div class="public anchor" id="var-freset.21"><h3>freset!</h3><div class="usage"><code>(freset! static-var newval)</code></div><div class="doc"><div class="markdown"><p>Sets the value of <code>static-var</code> to <code>newval</code>, running it through <a href="coffi.mem.html#var-serialize">serialize</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/ffi.clj#L647">view source</a></div></div><div class="public anchor" id="var-fswap.21"><h3>fswap!</h3><div class="usage"><code>(fswap! static-var f &amp; args)</code></div><div class="doc"><div class="markdown"><p>Non-atomically runs the function <code>f</code> over the value stored in <code>static-var</code>.</p>
 <p>The value is deserialized before passing it to <code>f</code>, and serialized before putting the value into <code>static-var</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/ffi.clj#L656">view source</a></div></div><div class="public anchor" id="var-load-library"><h3>load-library</h3><div class="usage"><code>(load-library path)</code></div><div class="doc"><div class="markdown"><p>Loads the library at <code>path</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/ffi.clj#L33">view source</a></div></div><div class="public anchor" id="var-load-system-library"><h3>load-system-library</h3><div class="usage"><code>(load-system-library libname)</code></div><div class="doc"><div class="markdown"><p>Loads the library named <code>libname</code> from the system’s load path.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/ffi.clj#L28">view source</a></div></div><div class="public anchor" id="var-make-downcall"><h3>make-downcall</h3><div class="usage"><code>(make-downcall symbol-or-addr args ret)</code></div><div class="doc"><div class="markdown"><p>Constructs a downcall function reference to <code>symbol-or-addr</code> with the given <code>args</code> and <code>ret</code> types.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/ffi.clj#L656">view source</a></div></div><div class="public anchor" id="var-load-library"><h3>load-library</h3><div class="usage"><code>(load-library path)</code></div><div class="doc"><div class="markdown"><p>Loads the library at <code>path</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/ffi.clj#L33">view source</a></div></div><div class="public anchor" id="var-load-system-library"><h3>load-system-library</h3><div class="usage"><code>(load-system-library libname)</code></div><div class="doc"><div class="markdown"><p>Loads the library named <code>libname</code> from the system’s load path.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/ffi.clj#L28">view source</a></div></div><div class="public anchor" id="var-make-downcall"><h3>make-downcall</h3><div class="usage"><code>(make-downcall symbol-or-addr args ret)</code></div><div class="doc"><div class="markdown"><p>Constructs a downcall function reference to <code>symbol-or-addr</code> with the given <code>args</code> and <code>ret</code> types.</p>
 <p>The function returned takes only arguments whose types match exactly the <a href="coffi.mem.html#var-java-layout">java-layout</a> for that type, and returns an argument with exactly the <a href="coffi.mem.html#var-java-layout">java-layout</a> of the <code>ret</code> type. This function will perform no serialization or deserialization of arguments or the return type.</p>
 <p>If the <code>ret</code> type is non-primitive, then the returned function will take a first argument of a <a href="null">SegmentAllocator</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/ffi.clj#L206">view source</a></div></div><div class="public anchor" id="var-make-serde-varargs-wrapper"><h3>make-serde-varargs-wrapper</h3><div class="usage"><code>(make-serde-varargs-wrapper varargs-factory required-args ret-type)</code></div><div class="doc"><div class="markdown"><p>Constructs a wrapper function for the <code>varargs-factory</code> which produces functions that serialize the arguments and deserialize the return value.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/ffi.clj#L426">view source</a></div></div><div class="public anchor" id="var-make-serde-wrapper"><h3>make-serde-wrapper</h3><div class="usage"><code>(make-serde-wrapper downcall arg-types ret-type)</code></div><div class="doc"><div class="markdown"><p>Constructs a wrapper function for the <code>downcall</code> which serializes the arguments and deserializes the return value.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/ffi.clj#L407">view source</a></div></div><div class="public anchor" id="var-make-varargs-factory"><h3>make-varargs-factory</h3><div class="usage"><code>(make-varargs-factory symbol required-args ret)</code></div><div class="doc"><div class="markdown"><p>Returns a function for constructing downcalls with additional types for arguments.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/ffi.clj#L206">view source</a></div></div><div class="public anchor" id="var-make-serde-varargs-wrapper"><h3>make-serde-varargs-wrapper</h3><div class="usage"><code>(make-serde-varargs-wrapper varargs-factory required-args ret-type)</code></div><div class="doc"><div class="markdown"><p>Constructs a wrapper function for the <code>varargs-factory</code> which produces functions that serialize the arguments and deserialize the return value.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/ffi.clj#L426">view source</a></div></div><div class="public anchor" id="var-make-serde-wrapper"><h3>make-serde-wrapper</h3><div class="usage"><code>(make-serde-wrapper downcall arg-types ret-type)</code></div><div class="doc"><div class="markdown"><p>Constructs a wrapper function for the <code>downcall</code> which serializes the arguments and deserializes the return value.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/ffi.clj#L407">view source</a></div></div><div class="public anchor" id="var-make-varargs-factory"><h3>make-varargs-factory</h3><div class="usage"><code>(make-varargs-factory symbol required-args ret)</code></div><div class="doc"><div class="markdown"><p>Returns a function for constructing downcalls with additional types for arguments.</p>
 <p>The <code>required-args</code> are the types of the first arguments passed to the downcall handle, and the values passed to the returned function are only the varargs types.</p>
 <p>The returned function is memoized, so that only one downcall function will be generated per combination of argument types.</p>
 <p>See <a href="coffi.ffi.html#var-make-downcall">make-downcall</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/ffi.clj#L222">view source</a></div></div><div class="public anchor" id="var-reify-libspec"><h3>reify-libspec</h3><div class="usage"><code>(reify-libspec libspec)</code></div><div class="doc"><div class="markdown"><p>Loads all the symbols specified in the <code>libspec</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/ffi.clj#L222">view source</a></div></div><div class="public anchor" id="var-reify-libspec"><h3>reify-libspec</h3><div class="usage"><code>(reify-libspec libspec)</code></div><div class="doc"><div class="markdown"><p>Loads all the symbols specified in the <code>libspec</code>.</p>
 <p>The value of each key of the passed map is transformed as by <a href="coffi.ffi.html#var-reify-symbolspec">reify-symbolspec</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/ffi.clj#L742">view source</a></div></div><div class="public anchor" id="var-reify-symbolspec"><h3>reify-symbolspec</h3><h4 class="type">multimethod</h4><div class="usage"></div><div class="doc"><div class="markdown"><p>Takes a spec for a symbol reference and returns a live value for that type.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/ffi.clj#L701">view source</a></div></div><div class="public anchor" id="var-static-variable"><h3>static-variable</h3><div class="usage"><code>(static-variable symbol-or-addr type)</code></div><div class="doc"><div class="markdown"><p>Constructs a reference to a mutable value stored in <code>symbol-or-addr</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/ffi.clj#L742">view source</a></div></div><div class="public anchor" id="var-reify-symbolspec"><h3>reify-symbolspec</h3><h4 class="type">multimethod</h4><div class="usage"></div><div class="doc"><div class="markdown"><p>Takes a spec for a symbol reference and returns a live value for that type.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/ffi.clj#L701">view source</a></div></div><div class="public anchor" id="var-static-variable"><h3>static-variable</h3><div class="usage"><code>(static-variable symbol-or-addr type)</code></div><div class="doc"><div class="markdown"><p>Constructs a reference to a mutable value stored in <code>symbol-or-addr</code>.</p>
 <p>The returned value can be dereferenced, and has metadata.</p>
 <p>See <a href="coffi.ffi.html#var-freset.21">freset!</a>, <a href="coffi.ffi.html#var-fswap.21">fswap!</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/ffi.clj#L672">view source</a></div></div><div class="public anchor" id="var-static-variable-segment"><h3>static-variable-segment</h3><div class="usage"><code>(static-variable-segment static-var)</code></div><div class="doc"><div class="markdown"><p>Gets the backing <a href="null">MemorySegment</a> from <code>static-var</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/ffi.clj#L672">view source</a></div></div><div class="public anchor" id="var-static-variable-segment"><h3>static-variable-segment</h3><div class="usage"><code>(static-variable-segment static-var)</code></div><div class="doc"><div class="markdown"><p>Gets the backing <a href="null">MemorySegment</a> from <code>static-var</code>.</p>
 <p>This is primarily useful when you need to pass the static variable’s address to a native function which takes an <a href="null">Addressable</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/ffi.clj#L664">view source</a></div></div><div class="public anchor" id="var-vacfn-factory"><h3>vacfn-factory</h3><div class="usage"><code>(vacfn-factory symbol required-args ret)</code></div><div class="doc"><div class="markdown"><p>Constructs a varargs factory to call the native function referenced by <code>symbol</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/ffi.clj#L664">view source</a></div></div><div class="public anchor" id="var-vacfn-factory"><h3>vacfn-factory</h3><div class="usage"><code>(vacfn-factory symbol required-args ret)</code></div><div class="doc"><div class="markdown"><p>Constructs a varargs factory to call the native function referenced by <code>symbol</code>.</p>
 <p>The function returned takes any number of type arguments and returns a specialized Clojure function for calling the native function with those arguments.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/ffi.clj#L453">view source</a></div></div></div></body></html>
\ No newline at end of file
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/ffi.clj#L453">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/coffi.layout.html b/docs/coffi.layout.html
index 11c4c01..bff4af1 100644
--- a/docs/coffi.layout.html
+++ b/docs/coffi.layout.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>coffi.layout documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch current"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="coffi.layout.html#var-with-c-layout"><div class="inner"><span>with-c-layout</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">coffi.layout</h1><div class="doc"><div class="markdown"><p>Functions for adjusting the layout of structs.</p>
+<html><head><meta charset="UTF-8" /><title>coffi.layout documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch current"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="coffi.layout.html#var-with-c-layout"><div class="inner"><span>with-c-layout</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">coffi.layout</h1><div class="doc"><div class="markdown"><p>Functions for adjusting the layout of structs.</p>
 </div></div><div class="public anchor" id="var-with-c-layout"><h3>with-c-layout</h3><div class="usage"><code>(with-c-layout struct-spec)</code></div><div class="doc"><div class="markdown"><p>Forces a struct specification to C layout rules.</p>
 <p>This will add padding fields between fields to match C alignment requirements.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/layout.clj#L6">view source</a></div></div></div></body></html>
\ No newline at end of file
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/layout.clj#L6">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/coffi.mem.html b/docs/coffi.mem.html
index 7cb91c2..cc459be 100644
--- a/docs/coffi.mem.html
+++ b/docs/coffi.mem.html
@@ -1,121 +1,121 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>coffi.mem documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2 current"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="coffi.mem.html#var-address-of"><div class="inner"><span>address-of</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-address.3F"><div class="inner"><span>address?</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-align-of"><div class="inner"><span>align-of</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-alloc"><div class="inner"><span>alloc</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-alloc-instance"><div class="inner"><span>alloc-instance</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-alloc-with"><div class="inner"><span>alloc-with</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-arena-allocator"><div class="inner"><span>arena-allocator</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-as-segment"><div class="inner"><span>as-segment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-auto-arena"><div class="inner"><span>auto-arena</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-big-endian"><div class="inner"><span>big-endian</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-byte-layout"><div class="inner"><span>byte-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-c-layout"><div class="inner"><span>c-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-char-layout"><div class="inner"><span>char-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-clone-segment"><div class="inner"><span>clone-segment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-confined-arena"><div class="inner"><span>confined-arena</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-copy-segment"><div class="inner"><span>copy-segment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-defalias"><div class="inner"><span>defalias</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-deserialize"><div class="inner"><span>deserialize</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-deserialize*"><div class="inner"><span>deserialize*</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-deserialize-from"><div class="inner"><span>deserialize-from</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-double-alignment"><div class="inner"><span>double-alignment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-double-layout"><div class="inner"><span>double-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-double-size"><div class="inner"><span>double-size</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-float-alignment"><div class="inner"><span>float-alignment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-float-layout"><div class="inner"><span>float-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-float-size"><div class="inner"><span>float-size</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-global-arena"><div class="inner"><span>global-arena</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-int-alignment"><div class="inner"><span>int-alignment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-int-layout"><div class="inner"><span>int-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-int-size"><div class="inner"><span>int-size</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-java-layout"><div class="inner"><span>java-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-java-prim-layout"><div class="inner"><span>java-prim-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-little-endian"><div class="inner"><span>little-endian</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-long-alignment"><div class="inner"><span>long-alignment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-long-layout"><div class="inner"><span>long-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-long-size"><div class="inner"><span>long-size</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-native-endian"><div class="inner"><span>native-endian</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-null"><div class="inner"><span>null</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-null.3F"><div class="inner"><span>null?</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-pointer-alignment"><div class="inner"><span>pointer-alignment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-pointer-layout"><div class="inner"><span>pointer-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-pointer-size"><div class="inner"><span>pointer-size</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-primitive-type"><div class="inner"><span>primitive-type</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-primitive-types"><div class="inner"><span>primitive-types</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-primitive.3F"><div class="inner"><span>primitive?</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-address"><div class="inner"><span>read-address</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-byte"><div class="inner"><span>read-byte</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-char"><div class="inner"><span>read-char</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-double"><div class="inner"><span>read-double</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-float"><div class="inner"><span>read-float</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-int"><div class="inner"><span>read-int</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-long"><div class="inner"><span>read-long</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-short"><div class="inner"><span>read-short</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-reinterpret"><div class="inner"><span>reinterpret</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-seq-of"><div class="inner"><span>seq-of</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-serialize"><div class="inner"><span>serialize</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-serialize*"><div class="inner"><span>serialize*</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-serialize-into"><div class="inner"><span>serialize-into</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-shared-arena"><div class="inner"><span>shared-arena</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-short-alignment"><div class="inner"><span>short-alignment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-short-layout"><div class="inner"><span>short-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-short-size"><div class="inner"><span>short-size</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-size-of"><div class="inner"><span>size-of</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-slice"><div class="inner"><span>slice</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-slice-segments"><div class="inner"><span>slice-segments</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-address"><div class="inner"><span>write-address</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-byte"><div class="inner"><span>write-byte</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-char"><div class="inner"><span>write-char</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-double"><div class="inner"><span>write-double</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-float"><div class="inner"><span>write-float</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-int"><div class="inner"><span>write-int</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-long"><div class="inner"><span>write-long</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-short"><div class="inner"><span>write-short</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">coffi.mem</h1><div class="doc"><div class="markdown"><p>Functions for managing native allocations, memory arenas, and (de)serialization.</p>
+<html><head><meta charset="UTF-8" /><title>coffi.mem documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2 current"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="coffi.mem.html#var-address-of"><div class="inner"><span>address-of</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-address.3F"><div class="inner"><span>address?</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-align-of"><div class="inner"><span>align-of</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-alloc"><div class="inner"><span>alloc</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-alloc-instance"><div class="inner"><span>alloc-instance</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-alloc-with"><div class="inner"><span>alloc-with</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-arena-allocator"><div class="inner"><span>arena-allocator</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-as-segment"><div class="inner"><span>as-segment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-auto-arena"><div class="inner"><span>auto-arena</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-big-endian"><div class="inner"><span>big-endian</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-byte-layout"><div class="inner"><span>byte-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-c-layout"><div class="inner"><span>c-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-char-layout"><div class="inner"><span>char-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-clone-segment"><div class="inner"><span>clone-segment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-confined-arena"><div class="inner"><span>confined-arena</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-copy-segment"><div class="inner"><span>copy-segment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-defalias"><div class="inner"><span>defalias</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-deserialize"><div class="inner"><span>deserialize</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-deserialize*"><div class="inner"><span>deserialize*</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-deserialize-from"><div class="inner"><span>deserialize-from</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-double-alignment"><div class="inner"><span>double-alignment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-double-layout"><div class="inner"><span>double-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-double-size"><div class="inner"><span>double-size</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-float-alignment"><div class="inner"><span>float-alignment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-float-layout"><div class="inner"><span>float-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-float-size"><div class="inner"><span>float-size</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-global-arena"><div class="inner"><span>global-arena</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-int-alignment"><div class="inner"><span>int-alignment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-int-layout"><div class="inner"><span>int-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-int-size"><div class="inner"><span>int-size</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-java-layout"><div class="inner"><span>java-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-java-prim-layout"><div class="inner"><span>java-prim-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-little-endian"><div class="inner"><span>little-endian</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-long-alignment"><div class="inner"><span>long-alignment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-long-layout"><div class="inner"><span>long-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-long-size"><div class="inner"><span>long-size</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-native-endian"><div class="inner"><span>native-endian</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-null"><div class="inner"><span>null</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-null.3F"><div class="inner"><span>null?</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-pointer-alignment"><div class="inner"><span>pointer-alignment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-pointer-layout"><div class="inner"><span>pointer-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-pointer-size"><div class="inner"><span>pointer-size</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-primitive-type"><div class="inner"><span>primitive-type</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-primitive-types"><div class="inner"><span>primitive-types</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-primitive.3F"><div class="inner"><span>primitive?</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-address"><div class="inner"><span>read-address</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-byte"><div class="inner"><span>read-byte</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-char"><div class="inner"><span>read-char</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-double"><div class="inner"><span>read-double</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-float"><div class="inner"><span>read-float</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-int"><div class="inner"><span>read-int</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-long"><div class="inner"><span>read-long</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-short"><div class="inner"><span>read-short</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-reinterpret"><div class="inner"><span>reinterpret</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-seq-of"><div class="inner"><span>seq-of</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-serialize"><div class="inner"><span>serialize</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-serialize*"><div class="inner"><span>serialize*</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-serialize-into"><div class="inner"><span>serialize-into</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-shared-arena"><div class="inner"><span>shared-arena</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-short-alignment"><div class="inner"><span>short-alignment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-short-layout"><div class="inner"><span>short-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-short-size"><div class="inner"><span>short-size</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-size-of"><div class="inner"><span>size-of</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-slice"><div class="inner"><span>slice</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-slice-segments"><div class="inner"><span>slice-segments</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-address"><div class="inner"><span>write-address</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-byte"><div class="inner"><span>write-byte</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-char"><div class="inner"><span>write-char</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-double"><div class="inner"><span>write-double</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-float"><div class="inner"><span>write-float</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-int"><div class="inner"><span>write-int</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-long"><div class="inner"><span>write-long</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-short"><div class="inner"><span>write-short</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">coffi.mem</h1><div class="doc"><div class="markdown"><p>Functions for managing native allocations, memory arenas, and (de)serialization.</p>
 <p>For any new type to be implemented, three multimethods must be overriden, but which three depends on the native representation of the type.</p>
 <p>If the native representation of the type is a primitive (whether or not other data beyond the primitive is associated with it, as e.g. a pointer), then <a href="coffi.mem.html#var-primitive-type">primitive-type</a> must be overriden to return which primitive type it is serialized as, then <a href="coffi.mem.html#var-serialize*">serialize*</a> and <a href="coffi.mem.html#var-deserialize*">deserialize*</a> should be overriden.</p>
 <p>If the native representation of the type is a composite type, like a union, struct, or array, then <a href="coffi.mem.html#var-c-layout">c-layout</a> must be overriden to return the native layout of the type, and <a href="coffi.mem.html#var-serialize-into">serialize-into</a> and <a href="coffi.mem.html#var-deserialize-from">deserialize-from</a> should be overriden to allow marshaling values of the type into and out of memory segments.</p>
 </div></div><div class="public anchor" id="var-address-of"><h3>address-of</h3><div class="usage"><code>(address-of addressable)</code></div><div class="doc"><div class="markdown"><p>Gets the address of a given segment as a number.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L108">view source</a></div></div><div class="public anchor" id="var-address.3F"><h3>address?</h3><div class="usage"><code>(address? addr)</code></div><div class="doc"><div class="markdown"><p>Checks if an object is a memory address.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L106">view source</a></div></div><div class="public anchor" id="var-address.3F"><h3>address?</h3><div class="usage"><code>(address? addr)</code></div><div class="doc"><div class="markdown"><p>Checks if an object is a memory address.</p>
 <p><code>nil</code> is considered an address.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L126">view source</a></div></div><div class="public anchor" id="var-align-of"><h3>align-of</h3><div class="usage"><code>(align-of type)</code></div><div class="doc"><div class="markdown"><p>The alignment in bytes of the given <code>type</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L813">view source</a></div></div><div class="public anchor" id="var-alloc"><h3>alloc</h3><div class="usage"><code>(alloc size)</code><code>(alloc size arena)</code><code>(alloc size alignment arena)</code></div><div class="doc"><div class="markdown"><p>Allocates <code>size</code> bytes.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L124">view source</a></div></div><div class="public anchor" id="var-align-of"><h3>align-of</h3><div class="usage"><code>(align-of type)</code></div><div class="doc"><div class="markdown"><p>The alignment in bytes of the given <code>type</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L811">view source</a></div></div><div class="public anchor" id="var-alloc"><h3>alloc</h3><div class="usage"><code>(alloc size)</code><code>(alloc size arena)</code><code>(alloc size alignment arena)</code></div><div class="doc"><div class="markdown"><p>Allocates <code>size</code> bytes.</p>
 <p>If an <code>arena</code> is provided, the allocation will be reclaimed when it is closed.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L93">view source</a></div></div><div class="public anchor" id="var-alloc-instance"><h3>alloc-instance</h3><div class="usage"><code>(alloc-instance type)</code><code>(alloc-instance type arena)</code></div><div class="doc"><div class="markdown"><p>Allocates a memory segment for the given <code>type</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L820">view source</a></div></div><div class="public anchor" id="var-alloc-with"><h3>alloc-with</h3><div class="usage"><code>(alloc-with allocator size)</code><code>(alloc-with allocator size alignment)</code></div><div class="doc"><div class="markdown"><p>Allocates <code>size</code> bytes using the <code>allocator</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L101">view source</a></div></div><div class="public anchor" id="var-arena-allocator"><h3>arena-allocator</h3><div class="usage"><code>(arena-allocator arena)</code></div><div class="doc"><div class="markdown"><p>Constructs a <a href="null">SegmentAllocator</a> from the given <a href="null">Arena</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L91">view source</a></div></div><div class="public anchor" id="var-alloc-instance"><h3>alloc-instance</h3><div class="usage"><code>(alloc-instance type)</code><code>(alloc-instance type arena)</code></div><div class="doc"><div class="markdown"><p>Allocates a memory segment for the given <code>type</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L818">view source</a></div></div><div class="public anchor" id="var-alloc-with"><h3>alloc-with</h3><div class="usage"><code>(alloc-with allocator size)</code><code>(alloc-with allocator size alignment)</code></div><div class="doc"><div class="markdown"><p>Allocates <code>size</code> bytes using the <code>allocator</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L99">view source</a></div></div><div class="public anchor" id="var-arena-allocator"><h3>arena-allocator</h3><div class="usage"><code>(arena-allocator arena)</code></div><div class="doc"><div class="markdown"><p>Constructs a <a href="null">SegmentAllocator</a> from the given <a href="null">Arena</a>.</p>
 <p>This is primarily used when working with unwrapped downcall functions. When a downcall function returns a non-primitive type, it must be provided with an allocator.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L82">view source</a></div></div><div class="public anchor" id="var-as-segment"><h3>as-segment</h3><div class="usage"><code>(as-segment address)</code><code>(as-segment address size)</code><code>(as-segment address size arena)</code><code>(as-segment address size arena cleanup)</code></div><div class="doc"><div class="markdown"><p>Dereferences an <code>address</code> into a memory segment associated with the <code>arena</code> (default global).</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L158">view source</a></div></div><div class="public anchor" id="var-auto-arena"><h3>auto-arena</h3><div class="usage"><code>(auto-arena)</code></div><div class="doc"><div class="markdown"><p>Constructs a new memory arena that is managed by the garbage collector.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L80">view source</a></div></div><div class="public anchor" id="var-as-segment"><h3>as-segment</h3><div class="usage"><code>(as-segment address)</code><code>(as-segment address size)</code><code>(as-segment address size arena)</code><code>(as-segment address size arena cleanup)</code></div><div class="doc"><div class="markdown"><p>Dereferences an <code>address</code> into a memory segment associated with the <code>arena</code> (default global).</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L156">view source</a></div></div><div class="public anchor" id="var-auto-arena"><h3>auto-arena</h3><div class="usage"><code>(auto-arena)</code></div><div class="doc"><div class="markdown"><p>Constructs a new memory arena that is managed by the garbage collector.</p>
 <p>The arena may be shared across threads, and all resources created with it will be cleaned up at the same time, when all references have been collected.</p>
 <p>This type of arena cannot be closed, and therefore should not be created in a <a href="null">with-open</a> clause.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L61">view source</a></div></div><div class="public anchor" id="var-big-endian"><h3>big-endian</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The big-endian <a href="null">ByteOrder</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L59">view source</a></div></div><div class="public anchor" id="var-big-endian"><h3>big-endian</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The big-endian <a href="null">ByteOrder</a>.</p>
 <p>See <a href="coffi.mem.html#var-little-endian">little-endian</a>, <a href="coffi.mem.html#var-native-endian">native-endian</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L189">view source</a></div></div><div class="public anchor" id="var-byte-layout"><h3>byte-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a byte in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L207">view source</a></div></div><div class="public anchor" id="var-c-layout"><h3>c-layout</h3><h4 class="type">multimethod</h4><div class="usage"></div><div class="doc"><div class="markdown"><p>Gets the layout object for a given <code>type</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L187">view source</a></div></div><div class="public anchor" id="var-byte-layout"><h3>byte-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a byte in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L205">view source</a></div></div><div class="public anchor" id="var-c-layout"><h3>c-layout</h3><h4 class="type">multimethod</h4><div class="usage"></div><div class="doc"><div class="markdown"><p>Gets the layout object for a given <code>type</code>.</p>
 <p>If a type is primitive it will return the appropriate primitive layout (see <a href="null">c-prim-layout</a>).</p>
 <p>Otherwise, it should return a <a href="null">GroupLayout</a> for the given type.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L731">view source</a></div></div><div class="public anchor" id="var-char-layout"><h3>char-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a c-sized char in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L223">view source</a></div></div><div class="public anchor" id="var-clone-segment"><h3>clone-segment</h3><div class="usage"><code>(clone-segment segment)</code><code>(clone-segment segment arena)</code></div><div class="doc"><div class="markdown"><p>Clones the content of <code>segment</code> into a new segment of the same size.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L176">view source</a></div></div><div class="public anchor" id="var-confined-arena"><h3>confined-arena</h3><div class="usage"><code>(confined-arena)</code></div><div class="doc"><div class="markdown"><p>Constructs a new arena for use only in this thread.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L729">view source</a></div></div><div class="public anchor" id="var-char-layout"><h3>char-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a c-sized char in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L221">view source</a></div></div><div class="public anchor" id="var-clone-segment"><h3>clone-segment</h3><div class="usage"><code>(clone-segment segment)</code><code>(clone-segment segment arena)</code></div><div class="doc"><div class="markdown"><p>Clones the content of <code>segment</code> into a new segment of the same size.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L174">view source</a></div></div><div class="public anchor" id="var-confined-arena"><h3>confined-arena</h3><div class="usage"><code>(confined-arena)</code></div><div class="doc"><div class="markdown"><p>Constructs a new arena for use only in this thread.</p>
 <p>The memory allocated within this arena is cheap to allocate, like a native stack.</p>
 <p>The memory allocated within this arena will be cleared once it is closed, so it is usually a good idea to create it in a <a href="null">with-open</a> clause.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L42">view source</a></div></div><div class="public anchor" id="var-copy-segment"><h3>copy-segment</h3><div class="usage"><code>(copy-segment dest src)</code></div><div class="doc"><div class="markdown"><p>Copies the content to <code>dest</code> from <code>src</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L40">view source</a></div></div><div class="public anchor" id="var-copy-segment"><h3>copy-segment</h3><div class="usage"><code>(copy-segment dest src)</code></div><div class="doc"><div class="markdown"><p>Copies the content to <code>dest</code> from <code>src</code>.</p>
 <p>Returns <code>dest</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L169">view source</a></div></div><div class="public anchor" id="var-defalias"><h3>defalias</h3><h4 class="type">macro</h4><div class="usage"><code>(defalias new-type aliased-type)</code></div><div class="doc"><div class="markdown"><p>Defines a type alias from <code>new-type</code> to <code>aliased-type</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L167">view source</a></div></div><div class="public anchor" id="var-defalias"><h3>defalias</h3><h4 class="type">macro</h4><div class="usage"><code>(defalias new-type aliased-type)</code></div><div class="doc"><div class="markdown"><p>Defines a type alias from <code>new-type</code> to <code>aliased-type</code>.</p>
 <p>This creates needed serialization and deserialization implementations for the aliased type.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L1321">view source</a></div></div><div class="public anchor" id="var-deserialize"><h3>deserialize</h3><div class="usage"><code>(deserialize obj type)</code></div><div class="doc"><div class="markdown"><p>Deserializes an arbitrary type.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L1319">view source</a></div></div><div class="public anchor" id="var-deserialize"><h3>deserialize</h3><div class="usage"><code>(deserialize obj type)</code></div><div class="doc"><div class="markdown"><p>Deserializes an arbitrary type.</p>
 <p>For types which have a primitive representation, this deserializes the primitive representation. For types which do not, this deserializes out of a segment.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L1094">view source</a></div></div><div class="public anchor" id="var-deserialize*"><h3>deserialize*</h3><h4 class="type">multimethod</h4><div class="usage"></div><div class="doc"><div class="markdown"><p>Deserializes a primitive object into a Clojure data structure.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L1092">view source</a></div></div><div class="public anchor" id="var-deserialize*"><h3>deserialize*</h3><h4 class="type">multimethod</h4><div class="usage"></div><div class="doc"><div class="markdown"><p>Deserializes a primitive object into a Clojure data structure.</p>
 <p>This is intended for use with types that are returned as a primitive but which need additional processing before they can be returned.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L1035">view source</a></div></div><div class="public anchor" id="var-deserialize-from"><h3>deserialize-from</h3><h4 class="type">multimethod</h4><div class="usage"></div><div class="doc"><div class="markdown"><p>Deserializes the given segment into a Clojure data structure.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L1033">view source</a></div></div><div class="public anchor" id="var-deserialize-from"><h3>deserialize-from</h3><h4 class="type">multimethod</h4><div class="usage"></div><div class="doc"><div class="markdown"><p>Deserializes the given segment into a Clojure data structure.</p>
 <p>For types that serialize to primitives, a default implementation will deserialize the primitive before calling <a href="coffi.mem.html#var-deserialize*">deserialize*</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L972">view source</a></div></div><div class="public anchor" id="var-double-alignment"><h3>double-alignment</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The alignment in bytes of a c-sized double.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L279">view source</a></div></div><div class="public anchor" id="var-double-layout"><h3>double-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a c-sized double in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L231">view source</a></div></div><div class="public anchor" id="var-double-size"><h3>double-size</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The size in bytes of a c-sized double.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L255">view source</a></div></div><div class="public anchor" id="var-float-alignment"><h3>float-alignment</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The alignment in bytes of a c-sized float.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L275">view source</a></div></div><div class="public anchor" id="var-float-layout"><h3>float-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a c-sized float in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L227">view source</a></div></div><div class="public anchor" id="var-float-size"><h3>float-size</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The size in bytes of a c-sized float.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L251">view source</a></div></div><div class="public anchor" id="var-global-arena"><h3>global-arena</h3><div class="usage"><code>(global-arena)</code></div><div class="doc"><div class="markdown"><p>Constructs the global arena, which will never reclaim its resources.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L970">view source</a></div></div><div class="public anchor" id="var-double-alignment"><h3>double-alignment</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The alignment in bytes of a c-sized double.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L277">view source</a></div></div><div class="public anchor" id="var-double-layout"><h3>double-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a c-sized double in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L229">view source</a></div></div><div class="public anchor" id="var-double-size"><h3>double-size</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The size in bytes of a c-sized double.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L253">view source</a></div></div><div class="public anchor" id="var-float-alignment"><h3>float-alignment</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The alignment in bytes of a c-sized float.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L273">view source</a></div></div><div class="public anchor" id="var-float-layout"><h3>float-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a c-sized float in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L225">view source</a></div></div><div class="public anchor" id="var-float-size"><h3>float-size</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The size in bytes of a c-sized float.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L249">view source</a></div></div><div class="public anchor" id="var-global-arena"><h3>global-arena</h3><div class="usage"><code>(global-arena)</code></div><div class="doc"><div class="markdown"><p>Constructs the global arena, which will never reclaim its resources.</p>
 <p>This arena may be shared across threads, but is intended mainly in cases where memory is allocated with <a href="coffi.mem.html#var-alloc">alloc</a> but is either never freed or whose management is relinquished to a native library, such as when returned from a callback.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L72">view source</a></div></div><div class="public anchor" id="var-int-alignment"><h3>int-alignment</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The alignment in bytes of a c-sized int.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L267">view source</a></div></div><div class="public anchor" id="var-int-layout"><h3>int-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a c-sized int in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L215">view source</a></div></div><div class="public anchor" id="var-int-size"><h3>int-size</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The size in bytes of a c-sized int.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L243">view source</a></div></div><div class="public anchor" id="var-java-layout"><h3>java-layout</h3><div class="usage"><code>(java-layout type)</code></div><div class="doc"><div class="markdown"><p>Gets the Java class to an argument of this type for a method handle.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L70">view source</a></div></div><div class="public anchor" id="var-int-alignment"><h3>int-alignment</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The alignment in bytes of a c-sized int.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L265">view source</a></div></div><div class="public anchor" id="var-int-layout"><h3>int-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a c-sized int in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L213">view source</a></div></div><div class="public anchor" id="var-int-size"><h3>int-size</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The size in bytes of a c-sized int.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L241">view source</a></div></div><div class="public anchor" id="var-java-layout"><h3>java-layout</h3><div class="usage"><code>(java-layout type)</code></div><div class="doc"><div class="markdown"><p>Gets the Java class to an argument of this type for a method handle.</p>
 <p>If a type serializes to a primitive it returns return a Java primitive type. Otherwise, it returns <a href="null">MemorySegment</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L798">view source</a></div></div><div class="public anchor" id="var-java-prim-layout"><h3>java-prim-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Map of primitive type names to the Java types for a method handle.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L786">view source</a></div></div><div class="public anchor" id="var-little-endian"><h3>little-endian</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The little-endian <a href="null">ByteOrder</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L796">view source</a></div></div><div class="public anchor" id="var-java-prim-layout"><h3>java-prim-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Map of primitive type names to the Java types for a method handle.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L784">view source</a></div></div><div class="public anchor" id="var-little-endian"><h3>little-endian</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The little-endian <a href="null">ByteOrder</a>.</p>
 <p>See <a href="coffi.mem.html#var-big-endian">big-endian</a>, <a href="coffi.mem.html#var-native-endian">native-endian</a></p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L195">view source</a></div></div><div class="public anchor" id="var-long-alignment"><h3>long-alignment</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The alignment in bytes of a c-sized long.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L271">view source</a></div></div><div class="public anchor" id="var-long-layout"><h3>long-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a c-sized long in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L219">view source</a></div></div><div class="public anchor" id="var-long-size"><h3>long-size</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The size in bytes of a c-sized long.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L247">view source</a></div></div><div class="public anchor" id="var-native-endian"><h3>native-endian</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">ByteOrder</a> for the native endianness of the current hardware.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L193">view source</a></div></div><div class="public anchor" id="var-long-alignment"><h3>long-alignment</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The alignment in bytes of a c-sized long.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L269">view source</a></div></div><div class="public anchor" id="var-long-layout"><h3>long-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a c-sized long in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L217">view source</a></div></div><div class="public anchor" id="var-long-size"><h3>long-size</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The size in bytes of a c-sized long.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L245">view source</a></div></div><div class="public anchor" id="var-native-endian"><h3>native-endian</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">ByteOrder</a> for the native endianness of the current hardware.</p>
 <p>See <a href="coffi.mem.html#var-big-endian">big-endian</a>, <a href="coffi.mem.html#var-little-endian">little-endian</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L201">view source</a></div></div><div class="public anchor" id="var-null"><h3>null</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The NULL pointer object.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L199">view source</a></div></div><div class="public anchor" id="var-null"><h3>null</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The NULL pointer object.</p>
 <p>While this object is safe to pass to functions which serialize to a pointer, it’s generally encouraged to simply pass <code>nil</code>. This value primarily exists to make it easier to write custom types with a primitive pointer representation.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L113">view source</a></div></div><div class="public anchor" id="var-null.3F"><h3>null?</h3><div class="usage"><code>(null? addr)</code></div><div class="doc"><div class="markdown"><p>Checks if a memory address is null.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L121">view source</a></div></div><div class="public anchor" id="var-pointer-alignment"><h3>pointer-alignment</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The alignment in bytes of a c-sized pointer.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L283">view source</a></div></div><div class="public anchor" id="var-pointer-layout"><h3>pointer-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a native pointer in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L235">view source</a></div></div><div class="public anchor" id="var-pointer-size"><h3>pointer-size</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The size in bytes of a c-sized pointer.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L259">view source</a></div></div><div class="public anchor" id="var-primitive-type"><h3>primitive-type</h3><h4 class="type">multimethod</h4><div class="usage"></div><div class="doc"><div class="markdown"><p>Gets the primitive type that is used to pass as an argument for the <code>type</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L111">view source</a></div></div><div class="public anchor" id="var-null.3F"><h3>null?</h3><div class="usage"><code>(null? addr)</code></div><div class="doc"><div class="markdown"><p>Checks if a memory address is null.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L119">view source</a></div></div><div class="public anchor" id="var-pointer-alignment"><h3>pointer-alignment</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The alignment in bytes of a c-sized pointer.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L281">view source</a></div></div><div class="public anchor" id="var-pointer-layout"><h3>pointer-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a native pointer in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L233">view source</a></div></div><div class="public anchor" id="var-pointer-size"><h3>pointer-size</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The size in bytes of a c-sized pointer.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L257">view source</a></div></div><div class="public anchor" id="var-primitive-type"><h3>primitive-type</h3><h4 class="type">multimethod</h4><div class="usage"></div><div class="doc"><div class="markdown"><p>Gets the primitive type that is used to pass as an argument for the <code>type</code>.</p>
 <p>This is for objects which are passed to native functions as primitive types, but which need additional logic to be performed during serialization and deserialization.</p>
 <p>Implementations of this method should take into account that type arguments may not always be evaluated before passing to this function.</p>
 <p>Returns nil for any type which does not have a primitive representation.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L678">view source</a></div></div><div class="public anchor" id="var-primitive-types"><h3>primitive-types</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>A set of all primitive types.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L668">view source</a></div></div><div class="public anchor" id="var-primitive.3F"><h3>primitive?</h3><div class="usage"><code>(primitive? type)</code></div><div class="doc"><div class="markdown"><p>A predicate to determine if a given type is primitive.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L673">view source</a></div></div><div class="public anchor" id="var-read-address"><h3>read-address</h3><div class="usage"><code>(read-address segment)</code><code>(read-address segment offset)</code></div><div class="doc"><div class="markdown"><p>Reads an address from the <code>segment</code>, at an optional <code>offset</code>, wrapped in a <a href="null">MemorySegment</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L444">view source</a></div></div><div class="public anchor" id="var-read-byte"><h3>read-byte</h3><div class="usage"><code>(read-byte segment)</code><code>(read-byte segment offset)</code></div><div class="doc"><div class="markdown"><p>Reads a <a href="null">byte</a> from the <code>segment</code>, at an optional <code>offset</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L287">view source</a></div></div><div class="public anchor" id="var-read-char"><h3>read-char</h3><div class="usage"><code>(read-char segment)</code><code>(read-char segment offset)</code></div><div class="doc"><div class="markdown"><p>Reads a <a href="null">char</a> from the <code>segment</code>, at an optional <code>offset</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L378">view source</a></div></div><div class="public anchor" id="var-read-double"><h3>read-double</h3><div class="usage"><code>(read-double segment)</code><code>(read-double segment offset)</code><code>(read-double segment offset byte-order)</code></div><div class="doc"><div class="markdown"><p>Reads a <a href="null">double</a> from the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L676">view source</a></div></div><div class="public anchor" id="var-primitive-types"><h3>primitive-types</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>A set of all primitive types.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L666">view source</a></div></div><div class="public anchor" id="var-primitive.3F"><h3>primitive?</h3><div class="usage"><code>(primitive? type)</code></div><div class="doc"><div class="markdown"><p>A predicate to determine if a given type is primitive.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L671">view source</a></div></div><div class="public anchor" id="var-read-address"><h3>read-address</h3><div class="usage"><code>(read-address segment)</code><code>(read-address segment offset)</code></div><div class="doc"><div class="markdown"><p>Reads an address from the <code>segment</code>, at an optional <code>offset</code>, wrapped in a <a href="null">MemorySegment</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L442">view source</a></div></div><div class="public anchor" id="var-read-byte"><h3>read-byte</h3><div class="usage"><code>(read-byte segment)</code><code>(read-byte segment offset)</code></div><div class="doc"><div class="markdown"><p>Reads a <a href="null">byte</a> from the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L285">view source</a></div></div><div class="public anchor" id="var-read-char"><h3>read-char</h3><div class="usage"><code>(read-char segment)</code><code>(read-char segment offset)</code></div><div class="doc"><div class="markdown"><p>Reads a <a href="null">char</a> from the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L376">view source</a></div></div><div class="public anchor" id="var-read-double"><h3>read-double</h3><div class="usage"><code>(read-double segment)</code><code>(read-double segment offset)</code><code>(read-double segment offset byte-order)</code></div><div class="doc"><div class="markdown"><p>Reads a <a href="null">double</a> from the <code>segment</code>, at an optional <code>offset</code>.</p>
 <p>If <code>byte-order</code> is not provided, it defaults to <a href="coffi.mem.html#var-native-endian">native-endian</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L419">view source</a></div></div><div class="public anchor" id="var-read-float"><h3>read-float</h3><div class="usage"><code>(read-float segment)</code><code>(read-float segment offset)</code><code>(read-float segment offset byte-order)</code></div><div class="doc"><div class="markdown"><p>Reads a <a href="null">float</a> from the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L417">view source</a></div></div><div class="public anchor" id="var-read-float"><h3>read-float</h3><div class="usage"><code>(read-float segment)</code><code>(read-float segment offset)</code><code>(read-float segment offset byte-order)</code></div><div class="doc"><div class="markdown"><p>Reads a <a href="null">float</a> from the <code>segment</code>, at an optional <code>offset</code>.</p>
 <p>If <code>byte-order</code> is not provided, it defaults to <a href="coffi.mem.html#var-native-endian">native-endian</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L394">view source</a></div></div><div class="public anchor" id="var-read-int"><h3>read-int</h3><div class="usage"><code>(read-int segment)</code><code>(read-int segment offset)</code><code>(read-int segment offset byte-order)</code></div><div class="doc"><div class="markdown"><p>Reads a <a href="null">int</a> from the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L392">view source</a></div></div><div class="public anchor" id="var-read-int"><h3>read-int</h3><div class="usage"><code>(read-int segment)</code><code>(read-int segment offset)</code><code>(read-int segment offset byte-order)</code></div><div class="doc"><div class="markdown"><p>Reads a <a href="null">int</a> from the <code>segment</code>, at an optional <code>offset</code>.</p>
 <p>If <code>byte-order</code> is not provided, it defaults to <a href="coffi.mem.html#var-native-endian">native-endian</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L328">view source</a></div></div><div class="public anchor" id="var-read-long"><h3>read-long</h3><div class="usage"><code>(read-long segment)</code><code>(read-long segment offset)</code><code>(read-long segment offset byte-order)</code></div><div class="doc"><div class="markdown"><p>Reads a <a href="null">long</a> from the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L326">view source</a></div></div><div class="public anchor" id="var-read-long"><h3>read-long</h3><div class="usage"><code>(read-long segment)</code><code>(read-long segment offset)</code><code>(read-long segment offset byte-order)</code></div><div class="doc"><div class="markdown"><p>Reads a <a href="null">long</a> from the <code>segment</code>, at an optional <code>offset</code>.</p>
 <p>If <code>byte-order</code> is not provided, it defaults to <a href="coffi.mem.html#var-native-endian">native-endian</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L353">view source</a></div></div><div class="public anchor" id="var-read-short"><h3>read-short</h3><div class="usage"><code>(read-short segment)</code><code>(read-short segment offset)</code><code>(read-short segment offset byte-order)</code></div><div class="doc"><div class="markdown"><p>Reads a <a href="null">short</a> from the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L351">view source</a></div></div><div class="public anchor" id="var-read-short"><h3>read-short</h3><div class="usage"><code>(read-short segment)</code><code>(read-short segment offset)</code><code>(read-short segment offset byte-order)</code></div><div class="doc"><div class="markdown"><p>Reads a <a href="null">short</a> from the <code>segment</code>, at an optional <code>offset</code>.</p>
 <p>If <code>byte-order</code> is not provided, it defaults to <a href="coffi.mem.html#var-native-endian">native-endian</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L303">view source</a></div></div><div class="public anchor" id="var-reinterpret"><h3>reinterpret</h3><div class="usage"><code>(reinterpret segment size)</code><code>(reinterpret segment size arena)</code><code>(reinterpret segment size arena cleanup)</code></div><div class="doc"><div class="markdown"><p>Reinterprets the <code>segment</code> as having the passed <code>size</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L301">view source</a></div></div><div class="public anchor" id="var-reinterpret"><h3>reinterpret</h3><div class="usage"><code>(reinterpret segment size)</code><code>(reinterpret segment size arena)</code><code>(reinterpret segment size arena cleanup)</code></div><div class="doc"><div class="markdown"><p>Reinterprets the <code>segment</code> as having the passed <code>size</code>.</p>
 <p>If <code>arena</code> is passed, the scope of the <code>segment</code> is associated with the arena, as well as its access constraints. If <code>cleanup</code> is passed, it will be a 1-argument function of a fresh memory segment backed by the same memory as the returned segment which should perform any required cleanup operations. It will be called when the <code>arena</code> is closed.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L140">view source</a></div></div><div class="public anchor" id="var-seq-of"><h3>seq-of</h3><div class="usage"><code>(seq-of type segment)</code></div><div class="doc"><div class="markdown"><p>Constructs a lazy sequence of <code>type</code> elements deserialized from <code>segment</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L1106">view source</a></div></div><div class="public anchor" id="var-serialize"><h3>serialize</h3><div class="usage"><code>(serialize obj type)</code><code>(serialize obj type arena)</code></div><div class="doc"><div class="markdown"><p>Serializes an arbitrary type.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L138">view source</a></div></div><div class="public anchor" id="var-seq-of"><h3>seq-of</h3><div class="usage"><code>(seq-of type segment)</code></div><div class="doc"><div class="markdown"><p>Constructs a lazy sequence of <code>type</code> elements deserialized from <code>segment</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L1104">view source</a></div></div><div class="public anchor" id="var-serialize"><h3>serialize</h3><div class="usage"><code>(serialize obj type)</code><code>(serialize obj type arena)</code></div><div class="doc"><div class="markdown"><p>Serializes an arbitrary type.</p>
 <p>For types which have a primitive representation, this serializes into that representation. For types which do not, it allocates a new segment and serializes into that.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L956">view source</a></div></div><div class="public anchor" id="var-serialize*"><h3>serialize*</h3><h4 class="type">multimethod</h4><div class="usage"></div><div class="doc"><div class="markdown"><p>Constructs a serialized version of the <code>obj</code> and returns it.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L954">view source</a></div></div><div class="public anchor" id="var-serialize*"><h3>serialize*</h3><h4 class="type">multimethod</h4><div class="usage"></div><div class="doc"><div class="markdown"><p>Constructs a serialized version of the <code>obj</code> and returns it.</p>
 <p>Any new allocations made during the serialization should be tied to the given <code>arena</code>, except in extenuating circumstances.</p>
 <p>This method should only be implemented for types that serialize to primitives.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L827">view source</a></div></div><div class="public anchor" id="var-serialize-into"><h3>serialize-into</h3><h4 class="type">multimethod</h4><div class="usage"></div><div class="doc"><div class="markdown"><p>Writes a serialized version of the <code>obj</code> to the given <code>segment</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L825">view source</a></div></div><div class="public anchor" id="var-serialize-into"><h3>serialize-into</h3><h4 class="type">multimethod</h4><div class="usage"></div><div class="doc"><div class="markdown"><p>Writes a serialized version of the <code>obj</code> to the given <code>segment</code>.</p>
 <p>Any new allocations made during the serialization should be tied to the given <code>arena</code>, except in extenuating circumstances.</p>
 <p>This method should be implemented for any type which does not override <a href="coffi.mem.html#var-c-layout">c-layout</a>.</p>
 <p>For any other type, this will serialize it as <a href="coffi.mem.html#var-serialize*">serialize*</a> before writing the result value into the <code>segment</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L887">view source</a></div></div><div class="public anchor" id="var-shared-arena"><h3>shared-arena</h3><div class="usage"><code>(shared-arena)</code></div><div class="doc"><div class="markdown"><p>Constructs a new shared memory arena.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L885">view source</a></div></div><div class="public anchor" id="var-shared-arena"><h3>shared-arena</h3><div class="usage"><code>(shared-arena)</code></div><div class="doc"><div class="markdown"><p>Constructs a new shared memory arena.</p>
 <p>This arena can be shared across threads and memory allocated in it will only be cleaned up once any thread accessing the arena closes it.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L53">view source</a></div></div><div class="public anchor" id="var-short-alignment"><h3>short-alignment</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The alignment in bytes of a c-sized short.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L263">view source</a></div></div><div class="public anchor" id="var-short-layout"><h3>short-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a c-sized short in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L211">view source</a></div></div><div class="public anchor" id="var-short-size"><h3>short-size</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The size in bytes of a c-sized short.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L239">view source</a></div></div><div class="public anchor" id="var-size-of"><h3>size-of</h3><div class="usage"><code>(size-of type)</code></div><div class="doc"><div class="markdown"><p>The size in bytes of the given <code>type</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L806">view source</a></div></div><div class="public anchor" id="var-slice"><h3>slice</h3><div class="usage"><code>(slice segment offset)</code><code>(slice segment offset size)</code></div><div class="doc"><div class="markdown"><p>Get a slice over the <code>segment</code> with the given <code>offset</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L133">view source</a></div></div><div class="public anchor" id="var-slice-segments"><h3>slice-segments</h3><div class="usage"><code>(slice-segments segment size)</code></div><div class="doc"><div class="markdown"><p>Constructs a lazy seq of <code>size</code>-length memory segments, sliced from <code>segment</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L182">view source</a></div></div><div class="public anchor" id="var-write-address"><h3>write-address</h3><div class="usage"><code>(write-address segment value)</code><code>(write-address segment offset value)</code></div><div class="doc"><div class="markdown"><p>Writes the address of the <a href="null">MemorySegment</a> <code>value</code> to the <code>segment</code>, at an optional <code>offset</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L642">view source</a></div></div><div class="public anchor" id="var-write-byte"><h3>write-byte</h3><div class="usage"><code>(write-byte segment value)</code><code>(write-byte segment offset value)</code></div><div class="doc"><div class="markdown"><p>Writes a <a href="null">byte</a> to the <code>segment</code>, at an optional <code>offset</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L460">view source</a></div></div><div class="public anchor" id="var-write-char"><h3>write-char</h3><div class="usage"><code>(write-char segment value)</code><code>(write-char segment offset value)</code></div><div class="doc"><div class="markdown"><p>Writes a <a href="null">char</a> to the <code>segment</code>, at an optional <code>offset</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L562">view source</a></div></div><div class="public anchor" id="var-write-double"><h3>write-double</h3><div class="usage"><code>(write-double segment value)</code><code>(write-double segment offset value)</code><code>(write-double segment offset byte-order value)</code></div><div class="doc"><div class="markdown"><p>Writes a <a href="null">double</a> to the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L51">view source</a></div></div><div class="public anchor" id="var-short-alignment"><h3>short-alignment</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The alignment in bytes of a c-sized short.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L261">view source</a></div></div><div class="public anchor" id="var-short-layout"><h3>short-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a c-sized short in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L209">view source</a></div></div><div class="public anchor" id="var-short-size"><h3>short-size</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The size in bytes of a c-sized short.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L237">view source</a></div></div><div class="public anchor" id="var-size-of"><h3>size-of</h3><div class="usage"><code>(size-of type)</code></div><div class="doc"><div class="markdown"><p>The size in bytes of the given <code>type</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L804">view source</a></div></div><div class="public anchor" id="var-slice"><h3>slice</h3><div class="usage"><code>(slice segment offset)</code><code>(slice segment offset size)</code></div><div class="doc"><div class="markdown"><p>Get a slice over the <code>segment</code> with the given <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L131">view source</a></div></div><div class="public anchor" id="var-slice-segments"><h3>slice-segments</h3><div class="usage"><code>(slice-segments segment size)</code></div><div class="doc"><div class="markdown"><p>Constructs a lazy seq of <code>size</code>-length memory segments, sliced from <code>segment</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L180">view source</a></div></div><div class="public anchor" id="var-write-address"><h3>write-address</h3><div class="usage"><code>(write-address segment value)</code><code>(write-address segment offset value)</code></div><div class="doc"><div class="markdown"><p>Writes the address of the <a href="null">MemorySegment</a> <code>value</code> to the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L640">view source</a></div></div><div class="public anchor" id="var-write-byte"><h3>write-byte</h3><div class="usage"><code>(write-byte segment value)</code><code>(write-byte segment offset value)</code></div><div class="doc"><div class="markdown"><p>Writes a <a href="null">byte</a> to the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L458">view source</a></div></div><div class="public anchor" id="var-write-char"><h3>write-char</h3><div class="usage"><code>(write-char segment value)</code><code>(write-char segment offset value)</code></div><div class="doc"><div class="markdown"><p>Writes a <a href="null">char</a> to the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L560">view source</a></div></div><div class="public anchor" id="var-write-double"><h3>write-double</h3><div class="usage"><code>(write-double segment value)</code><code>(write-double segment offset value)</code><code>(write-double segment offset byte-order value)</code></div><div class="doc"><div class="markdown"><p>Writes a <a href="null">double</a> to the <code>segment</code>, at an optional <code>offset</code>.</p>
 <p>If <code>byte-order</code> is not provided, it defaults to <a href="coffi.mem.html#var-native-endian">native-endian</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L614">view source</a></div></div><div class="public anchor" id="var-write-float"><h3>write-float</h3><div class="usage"><code>(write-float segment value)</code><code>(write-float segment offset value)</code><code>(write-float segment offset byte-order value)</code></div><div class="doc"><div class="markdown"><p>Writes a <a href="null">float</a> to the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L612">view source</a></div></div><div class="public anchor" id="var-write-float"><h3>write-float</h3><div class="usage"><code>(write-float segment value)</code><code>(write-float segment offset value)</code><code>(write-float segment offset byte-order value)</code></div><div class="doc"><div class="markdown"><p>Writes a <a href="null">float</a> to the <code>segment</code>, at an optional <code>offset</code>.</p>
 <p>If <code>byte-order</code> is not provided, it defaults to <a href="coffi.mem.html#var-native-endian">native-endian</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L586">view source</a></div></div><div class="public anchor" id="var-write-int"><h3>write-int</h3><div class="usage"><code>(write-int segment value)</code><code>(write-int segment offset value)</code><code>(write-int segment offset byte-order value)</code></div><div class="doc"><div class="markdown"><p>Writes a <a href="null">int</a> to the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L584">view source</a></div></div><div class="public anchor" id="var-write-int"><h3>write-int</h3><div class="usage"><code>(write-int segment value)</code><code>(write-int segment offset value)</code><code>(write-int segment offset byte-order value)</code></div><div class="doc"><div class="markdown"><p>Writes a <a href="null">int</a> to the <code>segment</code>, at an optional <code>offset</code>.</p>
 <p>If <code>byte-order</code> is not provided, it defaults to <a href="coffi.mem.html#var-native-endian">native-endian</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L506">view source</a></div></div><div class="public anchor" id="var-write-long"><h3>write-long</h3><div class="usage"><code>(write-long segment value)</code><code>(write-long segment offset value)</code><code>(write-long segment offset byte-order value)</code></div><div class="doc"><div class="markdown"><p>Writes a <a href="null">long</a> to the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L504">view source</a></div></div><div class="public anchor" id="var-write-long"><h3>write-long</h3><div class="usage"><code>(write-long segment value)</code><code>(write-long segment offset value)</code><code>(write-long segment offset byte-order value)</code></div><div class="doc"><div class="markdown"><p>Writes a <a href="null">long</a> to the <code>segment</code>, at an optional <code>offset</code>.</p>
 <p>If <code>byte-order</code> is not provided, it defaults to <a href="coffi.mem.html#var-native-endian">native-endian</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L534">view source</a></div></div><div class="public anchor" id="var-write-short"><h3>write-short</h3><div class="usage"><code>(write-short segment value)</code><code>(write-short segment offset value)</code><code>(write-short segment offset byte-order value)</code></div><div class="doc"><div class="markdown"><p>Writes a <a href="null">short</a> to the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L532">view source</a></div></div><div class="public anchor" id="var-write-short"><h3>write-short</h3><div class="usage"><code>(write-short segment value)</code><code>(write-short segment offset value)</code><code>(write-short segment offset byte-order value)</code></div><div class="doc"><div class="markdown"><p>Writes a <a href="null">short</a> to the <code>segment</code>, at an optional <code>offset</code>.</p>
 <p>If <code>byte-order</code> is not provided, it defaults to <a href="coffi.mem.html#var-native-endian">native-endian</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/a377c97c93a311a43100a5e05567680e6ae3c2de/src/clj/coffi/mem.clj#L478">view source</a></div></div></div></body></html>
\ No newline at end of file
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L476">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/index.html b/docs/index.html
index 36ad180..0e9517c 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>coffi v1.0.486</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></h1><div class="doc"><p>A Foreign Function Interface in Clojure for JDK 22+.</p></div><h2>Namespaces</h2><div class="namespace"><h3><a href="coffi.ffi.html">coffi.ffi</a></h3><div class="doc"><div class="markdown"><p>Functions for creating handles to native functions and loading native libraries.</p>
+<html><head><meta charset="UTF-8" /><title>coffi v1.0.486</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></h1><div class="doc"><p>A Foreign Function Interface in Clojure for JDK 22+.</p></div><h2>Topics</h2><ul class="topics"><li><a href="01-Getting-Started.html">Getting Started</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="coffi.ffi.html">coffi.ffi</a></h3><div class="doc"><div class="markdown"><p>Functions for creating handles to native functions and loading native libraries.</p>
 </div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="coffi.ffi.html#var-cfn">cfn</a> </li><li> <a href="coffi.ffi.html#var-const">const</a> </li><li> <a href="coffi.ffi.html#var-defcfn">defcfn</a> </li><li> <a href="coffi.ffi.html#var-defconst">defconst</a> </li><li> <a href="coffi.ffi.html#var-defvar">defvar</a> </li><li> <a href="coffi.ffi.html#var-ensure-symbol">ensure-symbol</a> </li><li> <a href="coffi.ffi.html#var-find-symbol">find-symbol</a> </li><li> <a href="coffi.ffi.html#var-freset.21">freset!</a> </li><li> <a href="coffi.ffi.html#var-fswap.21">fswap!</a> </li><li> <a href="coffi.ffi.html#var-load-library">load-library</a> </li><li> <a href="coffi.ffi.html#var-load-system-library">load-system-library</a> </li><li> <a href="coffi.ffi.html#var-make-downcall">make-downcall</a> </li><li> <a href="coffi.ffi.html#var-make-serde-varargs-wrapper">make-serde-varargs-wrapper</a> </li><li> <a href="coffi.ffi.html#var-make-serde-wrapper">make-serde-wrapper</a> </li><li> <a href="coffi.ffi.html#var-make-varargs-factory">make-varargs-factory</a> </li><li> <a href="coffi.ffi.html#var-reify-libspec">reify-libspec</a> </li><li> <a href="coffi.ffi.html#var-reify-symbolspec">reify-symbolspec</a> </li><li> <a href="coffi.ffi.html#var-static-variable">static-variable</a> </li><li> <a href="coffi.ffi.html#var-static-variable-segment">static-variable-segment</a> </li><li> <a href="coffi.ffi.html#var-vacfn-factory">vacfn-factory</a> </li></ul></div></div><div class="namespace"><h3><a href="coffi.layout.html">coffi.layout</a></h3><div class="doc"><div class="markdown"><p>Functions for adjusting the layout of structs.</p>
 </div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="coffi.layout.html#var-with-c-layout">with-c-layout</a> </li></ul></div></div><div class="namespace"><h3><a href="coffi.mem.html">coffi.mem</a></h3><div class="doc"><div class="markdown"><p>Functions for managing native allocations, memory arenas, and (de)serialization.</p>
 </div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="coffi.mem.html#var-address-of">address-of</a> </li><li> <a href="coffi.mem.html#var-address.3F">address?</a> </li><li> <a href="coffi.mem.html#var-align-of">align-of</a> </li><li> <a href="coffi.mem.html#var-alloc">alloc</a> </li><li> <a href="coffi.mem.html#var-alloc-instance">alloc-instance</a> </li><li> <a href="coffi.mem.html#var-alloc-with">alloc-with</a> </li><li> <a href="coffi.mem.html#var-arena-allocator">arena-allocator</a> </li><li> <a href="coffi.mem.html#var-as-segment">as-segment</a> </li><li> <a href="coffi.mem.html#var-auto-arena">auto-arena</a> </li><li> <a href="coffi.mem.html#var-big-endian">big-endian</a> </li><li> <a href="coffi.mem.html#var-byte-layout">byte-layout</a> </li><li> <a href="coffi.mem.html#var-c-layout">c-layout</a> </li><li> <a href="coffi.mem.html#var-char-layout">char-layout</a> </li><li> <a href="coffi.mem.html#var-clone-segment">clone-segment</a> </li><li> <a href="coffi.mem.html#var-confined-arena">confined-arena</a> </li><li> <a href="coffi.mem.html#var-copy-segment">copy-segment</a> </li><li> <a href="coffi.mem.html#var-defalias">defalias</a> </li><li> <a href="coffi.mem.html#var-deserialize">deserialize</a> </li><li> <a href="coffi.mem.html#var-deserialize*">deserialize*</a> </li><li> <a href="coffi.mem.html#var-deserialize-from">deserialize-from</a> </li><li> <a href="coffi.mem.html#var-double-alignment">double-alignment</a> </li><li> <a href="coffi.mem.html#var-double-layout">double-layout</a> </li><li> <a href="coffi.mem.html#var-double-size">double-size</a> </li><li> <a href="coffi.mem.html#var-float-alignment">float-alignment</a> </li><li> <a href="coffi.mem.html#var-float-layout">float-layout</a> </li><li> <a href="coffi.mem.html#var-float-size">float-size</a> </li><li> <a href="coffi.mem.html#var-global-arena">global-arena</a> </li><li> <a href="coffi.mem.html#var-int-alignment">int-alignment</a> </li><li> <a href="coffi.mem.html#var-int-layout">int-layout</a> </li><li> <a href="coffi.mem.html#var-int-size">int-size</a> </li><li> <a href="coffi.mem.html#var-java-layout">java-layout</a> </li><li> <a href="coffi.mem.html#var-java-prim-layout">java-prim-layout</a> </li><li> <a href="coffi.mem.html#var-little-endian">little-endian</a> </li><li> <a href="coffi.mem.html#var-long-alignment">long-alignment</a> </li><li> <a href="coffi.mem.html#var-long-layout">long-layout</a> </li><li> <a href="coffi.mem.html#var-long-size">long-size</a> </li><li> <a href="coffi.mem.html#var-native-endian">native-endian</a> </li><li> <a href="coffi.mem.html#var-null">null</a> </li><li> <a href="coffi.mem.html#var-null.3F">null?</a> </li><li> <a href="coffi.mem.html#var-pointer-alignment">pointer-alignment</a> </li><li> <a href="coffi.mem.html#var-pointer-layout">pointer-layout</a> </li><li> <a href="coffi.mem.html#var-pointer-size">pointer-size</a> </li><li> <a href="coffi.mem.html#var-primitive-type">primitive-type</a> </li><li> <a href="coffi.mem.html#var-primitive-types">primitive-types</a> </li><li> <a href="coffi.mem.html#var-primitive.3F">primitive?</a> </li><li> <a href="coffi.mem.html#var-read-address">read-address</a> </li><li> <a href="coffi.mem.html#var-read-byte">read-byte</a> </li><li> <a href="coffi.mem.html#var-read-char">read-char</a> </li><li> <a href="coffi.mem.html#var-read-double">read-double</a> </li><li> <a href="coffi.mem.html#var-read-float">read-float</a> </li><li> <a href="coffi.mem.html#var-read-int">read-int</a> </li><li> <a href="coffi.mem.html#var-read-long">read-long</a> </li><li> <a href="coffi.mem.html#var-read-short">read-short</a> </li><li> <a href="coffi.mem.html#var-reinterpret">reinterpret</a> </li><li> <a href="coffi.mem.html#var-seq-of">seq-of</a> </li><li> <a href="coffi.mem.html#var-serialize">serialize</a> </li><li> <a href="coffi.mem.html#var-serialize*">serialize*</a> </li><li> <a href="coffi.mem.html#var-serialize-into">serialize-into</a> </li><li> <a href="coffi.mem.html#var-shared-arena">shared-arena</a> </li><li> <a href="coffi.mem.html#var-short-alignment">short-alignment</a> </li><li> <a href="coffi.mem.html#var-short-layout">short-layout</a> </li><li> <a href="coffi.mem.html#var-short-size">short-size</a> </li><li> <a href="coffi.mem.html#var-size-of">size-of</a> </li><li> <a href="coffi.mem.html#var-slice">slice</a> </li><li> <a href="coffi.mem.html#var-slice-segments">slice-segments</a> </li><li> <a href="coffi.mem.html#var-write-address">write-address</a> </li><li> <a href="coffi.mem.html#var-write-byte">write-byte</a> </li><li> <a href="coffi.mem.html#var-write-char">write-char</a> </li><li> <a href="coffi.mem.html#var-write-double">write-double</a> </li><li> <a href="coffi.mem.html#var-write-float">write-float</a> </li><li> <a href="coffi.mem.html#var-write-int">write-int</a> </li><li> <a href="coffi.mem.html#var-write-long">write-long</a> </li><li> <a href="coffi.mem.html#var-write-short">write-short</a> </li></ul></div></div></div></body></html>
\ No newline at end of file

From 3c16e00fc1b7ca4d34d90c00003b7ea3785d9099 Mon Sep 17 00:00:00 2001
From: Joshua Suskalo <joshua@suskalo.org>
Date: Fri, 4 Oct 2024 16:15:36 -0400
Subject: [PATCH 4/6] Actually use url schemes for website links in the readme

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index c50f506..ec8fce4 100644
--- a/README.md
+++ b/README.md
@@ -11,8 +11,8 @@ doesn't remove the ability to write systems which minimize the cost of
 marshaling data and optimize for performance, to make use of the low-level
 access the FF&M API gives us.
 
-- [Getting Started](igjoshua.github.io/coffi/01-Getting-Started.html)
-- [API Documentation](igjoshua.github.io/coffi/)
+- [Getting Started](https://igjoshua.github.io/coffi/01-Getting-Started.html)
+- [API Documentation](https://igjoshua.github.io/coffi/)
 - [Recent Changes](CHANGELOG.md)
 
 ## Installation

From 58eaffdf543a3aa00436dafef2c65b247ad3f916 Mon Sep 17 00:00:00 2001
From: Joshua Suskalo <joshua@suskalo.org>
Date: Fri, 4 Oct 2024 16:27:06 -0400
Subject: [PATCH 5/6] Add more articles from readme sections

---
 docs/01-Getting-Started.html           |  23 +-
 docs/02-Memory-Management.html         |  18 ++
 docs/03-Builtin-Types.html             |  30 ++
 docs/04-Custom-Types.html              |  82 ++++++
 docs/05-Low-Level-Wrappers.html        |  51 ++++
 docs/50-Data-Model.html                |  25 ++
 docs/99-Benchmarks.html                | 258 +++++++++++++++++
 docs/articles/01-Getting-Started.md    |  34 +++
 docs/articles/02-Memory-Management.md  |  38 +++
 docs/articles/03-Builtin-Types.md      |  53 ++++
 docs/articles/04-Custom-Types.md       | 136 +++++++++
 docs/articles/05-Low-Level-Wrappers.md |  95 +++++++
 docs/articles/50-Data-Model.md         |  44 +++
 docs/articles/99-Benchmarks.md         | 373 +++++++++++++++++++++++++
 docs/coffi.ffi.html                    |  42 +--
 docs/coffi.layout.html                 |   4 +-
 docs/coffi.mem.html                    | 148 +++++-----
 docs/index.html                        |   2 +-
 18 files changed, 1357 insertions(+), 99 deletions(-)
 create mode 100644 docs/02-Memory-Management.html
 create mode 100644 docs/03-Builtin-Types.html
 create mode 100644 docs/04-Custom-Types.html
 create mode 100644 docs/05-Low-Level-Wrappers.html
 create mode 100644 docs/50-Data-Model.html
 create mode 100644 docs/99-Benchmarks.html
 create mode 100644 docs/articles/02-Memory-Management.md
 create mode 100644 docs/articles/03-Builtin-Types.md
 create mode 100644 docs/articles/04-Custom-Types.md
 create mode 100644 docs/articles/05-Low-Level-Wrappers.md
 create mode 100644 docs/articles/50-Data-Model.md
 create mode 100644 docs/articles/99-Benchmarks.md

diff --git a/docs/01-Getting-Started.html b/docs/01-Getting-Started.html
index fa78e5d..3d4bb2b 100644
--- a/docs/01-Getting-Started.html
+++ b/docs/01-Getting-Started.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Getting Started</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#getting-started" id="getting-started"></a>Getting Started</h1>
+<html><head><meta charset="UTF-8" /><title>Getting Started</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li><li class="depth-1 "><a href="02-Memory-Management.html"><div class="inner"><span>Memory Management</span></div></a></li><li class="depth-1 "><a href="03-Builtin-Types.html"><div class="inner"><span>Built-in Types</span></div></a></li><li class="depth-1 "><a href="04-Custom-Types.html"><div class="inner"><span>Custom Types</span></div></a></li><li class="depth-1 "><a href="05-Low-Level-Wrappers.html"><div class="inner"><span>Low-Level Wrappers</span></div></a></li><li class="depth-1 "><a href="50-Data-Model.html"><div class="inner"><span>Data Model</span></div></a></li><li class="depth-1 "><a href="99-Benchmarks.html"><div class="inner"><span>Benchmarks</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#getting-started" id="getting-started"></a>Getting Started</h1>
 <h2><a href="#installation" id="installation"></a>Installation</h2>
 <p>This library is available on Clojars. Add one of the following entries to the <code>:deps</code> key of your <code>deps.edn</code>:</p>
 <pre><code class="language-clojure">org.suskalo/coffi {:mvn/version "x.y.z"}
@@ -144,4 +144,25 @@ Point zero(void) {
 <p>Be aware however that there is no synchronization on these types. The value being read is not read atomically, so you may see an inconsistent state if the value is being mutated on another thread.</p>
 <p>A parallel function <code>fswap!</code> is also provided, but it does not provide any atomic semantics either.</p>
 <p>The memory that backs the static variable can be fetched with the function <code>static-variable-segment</code>, which can be used to pass a pointer to the static variable to native functions that require it.</p>
+<h3><a href="#complex-wrappers" id="complex-wrappers"></a>Complex Wrappers</h3>
+<p>Some functions require more complex code to map nicely to a Clojure function. The <code>defcfn</code> macro provides facilities to wrap the native function with some Clojure code to make this easier.</p>
+<pre><code class="language-clojure">(defcfn takes-array
+  "takes_array_with_count" [::mem/pointer ::mem/long] ::mem/void
+  native-fn
+  [ints]
+  (let [arr-len (count ints)
+        int-array (mem/serialize ints [::mem/array ::mem/int arr-len])]
+    (native-fn int-array arr-len)))
+</code></pre>
+<p>The symbol <code>native-fn</code> can be any unqualified symbol, and names the native function being wrapped. It must be called in the function body below if you want to call the native code.</p>
+<p>This <code>serialize</code> function has a paired <code>deserialize</code>, and allows marshaling Clojure data back and forth to native data structures.</p>
+<p>This can be used to implement out variables often seen in native code.</p>
+<pre><code class="language-clojure">(defcfn out-int
+  "out_int" [::mem/pointer] ::mem/void
+  native-fn
+  [i]
+  (let [int-ptr (mem/serialize i [::mem/pointer ::mem/int])]
+    (native-fn int-ptr)
+    (mem/deserialize int-ptr [::mem/pointer ::mem/int])))
+</code></pre>
 </div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/02-Memory-Management.html b/docs/02-Memory-Management.html
new file mode 100644
index 0000000..a0489fa
--- /dev/null
+++ b/docs/02-Memory-Management.html
@@ -0,0 +1,18 @@
+<!DOCTYPE html PUBLIC ""
+    "">
+<html><head><meta charset="UTF-8" /><title>Memory Management</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li><li class="depth-1  current"><a href="02-Memory-Management.html"><div class="inner"><span>Memory Management</span></div></a></li><li class="depth-1 "><a href="03-Builtin-Types.html"><div class="inner"><span>Built-in Types</span></div></a></li><li class="depth-1 "><a href="04-Custom-Types.html"><div class="inner"><span>Custom Types</span></div></a></li><li class="depth-1 "><a href="05-Low-Level-Wrappers.html"><div class="inner"><span>Low-Level Wrappers</span></div></a></li><li class="depth-1 "><a href="50-Data-Model.html"><div class="inner"><span>Data Model</span></div></a></li><li class="depth-1 "><a href="99-Benchmarks.html"><div class="inner"><span>Benchmarks</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#memory-management" id="memory-management"></a>Memory Management</h1>
+<p>In order to serialize any non-primitive type, off-heap memory needs to be allocated. When memory is allocated inside the JVM, the memory is associated with an arena. If none is provided, the arena is an implicit arena, and the memory will be freed when the serialized object is garbage collected.</p>
+<p>In many cases this is not desirable, because the memory is not freed in a deterministic manner, causing garbage collection pauses to become longer, as well as changing allocation performance. Instead of an implicit arena, there are other kinds of arenas as well. A <code>confined-arena</code> is a thread-local arena. Confined arenas are <code>Closeable</code>, which means they should usually be used in a <code>with-open</code> form. When a <code>confined-arena</code> is closed, it immediately frees all the memory associated with it. The previous example, <code>out-int</code>, can be implemented with a confined arena.</p>
+<pre><code class="language-clojure">(defcfn out-int
+  "out_int" [::mem/pointer] ::mem/void
+  native-fn
+  [i]
+  (with-open [arena (mem/confined-arena)]
+    (let [int-ptr (mem/serialize i [::mem/pointer ::mem/int] arena)]
+      (native-fn int-ptr)
+      (mem/deserialize int-ptr [::mem/pointer ::mem/int]))))
+</code></pre>
+<p>This will free the pointer immediately upon leaving the function.</p>
+<p>When memory needs to be accessible from multiple threads, there’s <code>shared-arena</code>. When a <code>shared-arena</code> is <code>.close</code>d, it will release all its associated memory immediately, and so this should only be done once all other threads are done accessing memory associated with it.</p>
+<p>In addition, two non-<code>Closeable</code> arenas are <code>global-arena</code>, which never frees the resources associated with it, and <code>auto-arena</code>, which is an arena that frees its resources once all of them are unreachable during a garbage collection cycle, like an implicit arena, but potentially for multiple allocations rather than just one.</p>
+</div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/03-Builtin-Types.html b/docs/03-Builtin-Types.html
new file mode 100644
index 0000000..ca6ec7d
--- /dev/null
+++ b/docs/03-Builtin-Types.html
@@ -0,0 +1,30 @@
+<!DOCTYPE html PUBLIC ""
+    "">
+<html><head><meta charset="UTF-8" /><title>Built-in Types</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li><li class="depth-1 "><a href="02-Memory-Management.html"><div class="inner"><span>Memory Management</span></div></a></li><li class="depth-1  current"><a href="03-Builtin-Types.html"><div class="inner"><span>Built-in Types</span></div></a></li><li class="depth-1 "><a href="04-Custom-Types.html"><div class="inner"><span>Custom Types</span></div></a></li><li class="depth-1 "><a href="05-Low-Level-Wrappers.html"><div class="inner"><span>Low-Level Wrappers</span></div></a></li><li class="depth-1 "><a href="50-Data-Model.html"><div class="inner"><span>Data Model</span></div></a></li><li class="depth-1 "><a href="99-Benchmarks.html"><div class="inner"><span>Benchmarks</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#built-in-types" id="built-in-types"></a>Built-in Types</h1>
+<h3><a href="#primitives" id="primitives"></a>Primitives</h3>
+<h3><a href="#arrays" id="arrays"></a>Arrays</h3>
+<h3><a href="#pointers" id="pointers"></a>Pointers</h3>
+<h3><a href="#structs" id="structs"></a>Structs</h3>
+<h3><a href="#enums" id="enums"></a>Enums</h3>
+<h3><a href="#flagsets" id="flagsets"></a>Flagsets</h3>
+<h3><a href="#unions" id="unions"></a>Unions</h3>
+<p>Unions in coffi are rather limited. They can be serialized, but not deserialized without external information.</p>
+<pre><code class="language-clojure">[::mem/union
+ #{::mem/float ::mem/double}
+ :dispatch #(cond
+             (float? %) ::mem/float
+             (double? %) ::mem/double)]
+</code></pre>
+<p>This is a minimal union in coffi. If the <code>:dispatch</code> keyword argument is not passed, then the union cannot be serialized, as coffi would not know which type to serialize the values as. In the example with a tagged union, a dispatch function was not provided because the type was only used for the native layout.</p>
+<p>In addition to a dispatch function, when serializing a union an extract function may also be provided. In the case of the value in the tagged union from before, it could be represented for serialization purposes like so:</p>
+<pre><code class="language-clojure">[::mem/union
+ #{::mem/int ::mem/c-string}
+ :dispatch #(case (first %)
+              :ok ::mem/int
+              :err ::mem/c-string)
+ :extract second]
+</code></pre>
+<p>This union however would not include the tag when serialized.</p>
+<p>If a union is deserialized, then all that coffi does is to allocate a new segment of the appropriate size with an implicit arena so that it may later be garbage collected, and copies the data from the source segment into it. It’s up to the user to call <code>deserialize-from</code> on that segment with the appropriate type.</p>
+<h3><a href="#raw-types" id="raw-types"></a>Raw Types</h3>
+</div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/04-Custom-Types.html b/docs/04-Custom-Types.html
new file mode 100644
index 0000000..50e6805
--- /dev/null
+++ b/docs/04-Custom-Types.html
@@ -0,0 +1,82 @@
+<!DOCTYPE html PUBLIC ""
+    "">
+<html><head><meta charset="UTF-8" /><title>Custom Types</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li><li class="depth-1 "><a href="02-Memory-Management.html"><div class="inner"><span>Memory Management</span></div></a></li><li class="depth-1 "><a href="03-Builtin-Types.html"><div class="inner"><span>Built-in Types</span></div></a></li><li class="depth-1  current"><a href="04-Custom-Types.html"><div class="inner"><span>Custom Types</span></div></a></li><li class="depth-1 "><a href="05-Low-Level-Wrappers.html"><div class="inner"><span>Low-Level Wrappers</span></div></a></li><li class="depth-1 "><a href="50-Data-Model.html"><div class="inner"><span>Data Model</span></div></a></li><li class="depth-1 "><a href="99-Benchmarks.html"><div class="inner"><span>Benchmarks</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#custom-types" id="custom-types"></a>Custom Types</h1>
+<p>Custom types with serializers and deserializers may be created. This is done using two sets of three multimethods which can be extended by the user. For any given type, only one set need be implemented.</p>
+<p>Two examples of custom types are given here, one is a 3d vector, and the other an example of a tagged union.</p>
+<h3><a href="#vector3" id="vector3"></a>Vector3</h3>
+<p>For the vector type, it will serialize to a pointer to an array of three floats.</p>
+<p>The multimethod <code>primitive-type</code> returns the primitive type that a given type serializes to. For this example, it should be a pointer.</p>
+<pre><code class="language-clojure">(defmethod mem/primitive-type ::vector
+  [_type]
+  ::mem/pointer)
+</code></pre>
+<p>For any type which doesn’t serialize to a primitive, it returns nil, and therefore need not be overriden.</p>
+<p>Next is <code>serialize*</code> and <code>deserialize*</code>, multimethods that work with types that serialize to primitives.</p>
+<pre><code class="language-clojure">(defmethod mem/serialize* ::vector
+  [obj _type arena]
+  (mem/serialize obj [::mem/array ::mem/float 3] arena))
+
+(defmethod mem/deserialize* ::vector
+  [segment _type]
+  (mem/deserialize (mem/reinterpret segment (mem/size-of [::mem/array ::mem/float 3]))
+                   [::mem/array ::mem/float 3]))
+</code></pre>
+<p>The <code>reinterpret</code> function allows you to take a segment and decorate it with a new size, and possibly associate it with an arena or add cleanup functions on it.</p>
+<p>In cases like this where we don’t know the arena of the pointer, we could use <code>reinterpret</code> to ensure it’s freed. For example if a <code>free-vector!</code> function that takes a pointer exists, we could use this:</p>
+<pre><code class="language-clojure">(defcfn returns-vector
+  "returns_vector" [] ::mem/pointer
+  native-fn
+  [arena]
+  (let [ret-ptr (native-fn)]
+    (-&gt; (reinterpret ret-ptr (mem/size-of ::vector) arena free-vector!)
+        (deserialize ::vector))))
+</code></pre>
+<p>This function takes an arena and returns the deserialized vector, and it will free the pointer when the arena closes.</p>
+<h3><a href="#tagged-union" id="tagged-union"></a>Tagged Union</h3>
+<p>For the tagged union type, we will represent the value as a vector of a keyword naming the tag and the value. The type itself will need to take arguments, similar to <code>struct</code>. For example, if we were to represent a result type like in Rust, we might have the following values:</p>
+<pre><code class="language-clojure">[:ok 5]
+[:err "Invalid number format"]
+</code></pre>
+<p>To represent this, we can have a <code>tagged-union</code> type. For this instance of the result type, it may look like this:</p>
+<pre><code class="language-clojure">[::tagged-union [:ok :err] {:ok ::mem/int :err ::mem/c-string}]
+</code></pre>
+<p>The native representation of these objects is a struct of the tag and a union of the value. In order to correctly serialize the data and pass it to native code, we need a representation of the native layout of the data. The <code>c-layout</code> multimethod provides that.</p>
+<pre><code class="language-clojure">(defmethod mem/c-layout ::tagged-union
+  [[_tagged-union tags type-map]]
+  (mem/c-layout [::mem/struct
+                 [[:tag ::mem/long]
+                  [:value [::mem/union (vals type-map)]]]]))
+</code></pre>
+<p>Types with type arguments are represented as vectors of the type name and any additional arguments. The type name is what is dispatched on for the multimethods.</p>
+<p>Now that we have a native layout, we need to be able to serialize and deserialize the value into and out of memory segments. This is accomplished with <code>serialize-into</code> and <code>deserialize-from</code>.</p>
+<pre><code class="language-clojure">(defn item-index
+  "Gets the index of the first occurance of `item` in `coll`."
+  [coll item]
+  (first
+   (-&gt;&gt; coll
+        (map-indexed vector)
+        (filter (comp #{item} second))
+        (map first))))
+
+(defmethod mem/serialize-into ::tagged-union
+  [obj [_tagged-union tags type-map] segment arena]
+  (mem/serialize-into
+   {:tag (item-index tags (first obj))
+    :value (second obj)}
+   [::mem/struct
+    [[:tag ::mem/long]
+     [:value (get type-map (first obj))]]]
+   segment
+   arena))
+</code></pre>
+<p>This serialization method is rather simple, it just turns the vector value into a map, and serializes it as a struct, choosing the type of the value based on the tag.</p>
+<pre><code class="language-clojure">(defmethod mem/deserialize-from ::tagged-union
+  [segment [_tagged-union tags type-map]]
+  (let [tag (mem/deserialize-from segment ::mem/long)]
+    [(nth tags tag)
+     (mem/deserialize-from
+      (mem/slice segment (mem/size-of ::mem/long))
+      (get type-map tag))]))
+</code></pre>
+<p>Deserialization is a little more complex. First the tag is retrieved from the beginning of the segment, and then the type of the value is decided based on that before it is deserialized.</p>
+</div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/05-Low-Level-Wrappers.html b/docs/05-Low-Level-Wrappers.html
new file mode 100644
index 0000000..0b9ab2c
--- /dev/null
+++ b/docs/05-Low-Level-Wrappers.html
@@ -0,0 +1,51 @@
+<!DOCTYPE html PUBLIC ""
+    "">
+<html><head><meta charset="UTF-8" /><title>Low-Level Wrappers</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li><li class="depth-1 "><a href="02-Memory-Management.html"><div class="inner"><span>Memory Management</span></div></a></li><li class="depth-1 "><a href="03-Builtin-Types.html"><div class="inner"><span>Built-in Types</span></div></a></li><li class="depth-1 "><a href="04-Custom-Types.html"><div class="inner"><span>Custom Types</span></div></a></li><li class="depth-1  current"><a href="05-Low-Level-Wrappers.html"><div class="inner"><span>Low-Level Wrappers</span></div></a></li><li class="depth-1 "><a href="50-Data-Model.html"><div class="inner"><span>Data Model</span></div></a></li><li class="depth-1 "><a href="99-Benchmarks.html"><div class="inner"><span>Benchmarks</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#low-level-wrappers" id="low-level-wrappers"></a>Low-Level Wrappers</h1>
+<h3><a href="#unwrapped-native-handles" id="unwrapped-native-handles"></a>Unwrapped Native Handles</h3>
+<p>Some native libraries work with handles to large amounts of data at once, making it undesirable to marshal data back and forth from Clojure, both because it’s not necessary to work with the data in Clojure directly, or also because of the high (de)serialization costs associated with marshaling. In cases like these, unwrapped native handles are desirable.</p>
+<p>The functions <code>make-downcall</code> and <code>make-varargs-factory</code> are also provided to create raw function handles.</p>
+<pre><code class="language-clojure">(def raw-strlen (ffi/make-downcall "strlen" [::mem/c-string] ::mem/long))
+(raw-strlen (mem/serialize "hello" ::mem/c-string))
+;; =&gt; 5
+</code></pre>
+<p>With raw handles, the argument types are expected to exactly match the types expected by the native function. For primitive types, those are primitives. For pointers, that is <code>MemorySegment</code>, and for composite types like structs and unions, that is also <code>MemorySegment</code>. <code>MemorySegment</code> comes from the <code>java.lang.foreign</code> package.</p>
+<p>In addition, when a raw handle returns a composite type represented with a <code>MemorySegment</code>, it requires an additional first argument, a <code>SegmentAllocator</code>, which can be acquired with <code>arena-allocator</code> to get one associated with a specific arena. The returned value will live until that arena is released.</p>
+<p>In addition, function types can be specified as being raw, in the following manner:</p>
+<pre><code class="language-clojure">[::ffi/fn [::mem/int] ::mem/int :raw-fn? true]
+</code></pre>
+<p>Clojure functions serialized to this type will have their arguments and return value exactly match the types specified and will not perform any serialization or deserialization at their boundaries.</p>
+<p>One important caveat to consider when writing wrappers for performance-sensitive functions is that the convenience macro <code>defcfn</code> that coffi provides will already perform no serialization or deserialization on primitive arguments and return types, so for functions with only primitive argument and return types there is no performance reason to choose unwrapped native handles over the convenience macro.</p>
+<h3><a href="#manual-deserialization" id="manual-deserialization"></a>Manual (De)Serialization</h3>
+<p>Coffi uses multimethods to dispatch to (de)serialization functions to enable code that’s generic over the types it operates on. However, in cases where you know the exact types that you will be (de)serializing and the multimethod dispatch overhead is too high a cost, it may be appropriate to manually handle (de)serializing data. This will often be done paired with <a href="#unwrapped-native-handles">Unwrapped Native Handles</a>.</p>
+<p>Convenience functions are provided to both read and write all primitive types and addresses, including byte order.</p>
+<p>As an example, when wrapping a function that returns an array of big-endian floats, the following code might be used.</p>
+<pre><code class="language-clojure">;; int returns_float_array(float **arr)
+(def ^:private returns-float-array* (ffi/make-downcall "returns_float_array" [::mem/pointer] ::mem/int))
+;; void releases_float_array(float *arr)
+(def ^:private release-floats* (ffi/make-downcall "releases_float_array" [::mem/pointer] ::mem/void))
+
+(defn returns-float-array
+  []
+  (with-open [arena (mem/confined-arena)]
+    ;; float *out_floats;
+    ;; int num_floats = returns_float_array(&amp;out_floats);
+    (let [out-floats (mem/alloc mem/pointer-size arena)
+          num-floats (returns-float-array* out-floats)
+          floats-addr (mem/read-address out-floats)
+          floats-slice (mem/reinterpret floats-addr (unchecked-multiply-int mem/float-size num-floats))]
+      ;; Using a try/finally to perform an operation when the stack frame exits,
+      ;; but not to try to catch anything.
+      (try
+        (loop [floats (transient [])
+               index 0]
+          (if (&gt;= index num-floats)
+            (persistent! floats)
+            (recur (conj! floats (mem/read-float floats-slice
+                                                 (unchecked-multiply-int index mem/float-size)
+                                                 mem/big-endian))
+                   (unchecked-inc-int index))))
+        (finally
+          (release-floats* floats-addr))))))
+</code></pre>
+<p>The above code manually performs all memory operations rather than relying on coffi’s dispatch. This will be more performant, but because multimethod overhead is usually relatively low, it’s recommended to use the multimethod variants for convenience in colder functions.</p>
+</div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/50-Data-Model.html b/docs/50-Data-Model.html
new file mode 100644
index 0000000..aba841f
--- /dev/null
+++ b/docs/50-Data-Model.html
@@ -0,0 +1,25 @@
+<!DOCTYPE html PUBLIC ""
+    "">
+<html><head><meta charset="UTF-8" /><title>Data Model</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li><li class="depth-1 "><a href="02-Memory-Management.html"><div class="inner"><span>Memory Management</span></div></a></li><li class="depth-1 "><a href="03-Builtin-Types.html"><div class="inner"><span>Built-in Types</span></div></a></li><li class="depth-1 "><a href="04-Custom-Types.html"><div class="inner"><span>Custom Types</span></div></a></li><li class="depth-1 "><a href="05-Low-Level-Wrappers.html"><div class="inner"><span>Low-Level Wrappers</span></div></a></li><li class="depth-1  current"><a href="50-Data-Model.html"><div class="inner"><span>Data Model</span></div></a></li><li class="depth-1 "><a href="99-Benchmarks.html"><div class="inner"><span>Benchmarks</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#data-model" id="data-model"></a>Data Model</h1>
+<p>In addition to the macros and functions provided to build a Clojure API for native libraries, facilities are provided for taking data and loading all the symbols specified by it. This can be useful if a library provides (or an external provider maintains) a data representation of their API, as Clojure data to represent it may be programmatically generated from these sources.</p>
+<p>The data to represent an API is a map with the following form:</p>
+<pre><code class="language-clojure">(def strlen-libspec
+  {:strlen {:type :function
+            :symbol "strlen"
+            :function/args [::mem/c-string]
+            :function/ret ::mem/long}})
+</code></pre>
+<p>Each key in this map represents a single symbol to be loaded. The value is a map with at least the keys <code>:type</code> and <code>:symbol</code>. These are the currently recognized types:</p>
+<ul>
+<li>function</li>
+<li>varargs-factory</li>
+<li>const</li>
+<li>static-var</li>
+</ul>
+<p>Each one has its own set of additional keys which can be added to the map. Both <code>function</code> and <code>varargs-factory</code> have the three keys <code>:function/args</code>, <code>:function/ret</code>, and <code>:function/raw-fn?</code>. The <code>const</code> type has <code>:const/type</code> and <code>static-var</code> has <code>:static-var/type</code>.</p>
+<p>This data can be passed to the function <code>reify-libspec</code>, which will take the data and return a map from the same keys as the input map to whatever value is appropriate for a given symbol type (e.g. a Clojure function for <code>function</code>, a value for <code>const</code>, etc.).</p>
+<pre><code class="language-clojure">(ffi/reify-libspec strlen-libspec)
+;; =&gt; {:strlen #function[...]}
+</code></pre>
+<p>This functionality can be extended by specifying new types as implementations of the multimethod <code>reify-symbolspec</code>, although it’s recommended that for any library authors who do so, namespaced keywords be used to name types.</p>
+</div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/99-Benchmarks.html b/docs/99-Benchmarks.html
new file mode 100644
index 0000000..0009067
--- /dev/null
+++ b/docs/99-Benchmarks.html
@@ -0,0 +1,258 @@
+<!DOCTYPE html PUBLIC ""
+    "">
+<html><head><meta charset="UTF-8" /><title>Benchmarks</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li><li class="depth-1 "><a href="02-Memory-Management.html"><div class="inner"><span>Memory Management</span></div></a></li><li class="depth-1 "><a href="03-Builtin-Types.html"><div class="inner"><span>Built-in Types</span></div></a></li><li class="depth-1 "><a href="04-Custom-Types.html"><div class="inner"><span>Custom Types</span></div></a></li><li class="depth-1 "><a href="05-Low-Level-Wrappers.html"><div class="inner"><span>Low-Level Wrappers</span></div></a></li><li class="depth-1 "><a href="50-Data-Model.html"><div class="inner"><span>Data Model</span></div></a></li><li class="depth-1  current"><a href="99-Benchmarks.html"><div class="inner"><span>Benchmarks</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#benchmarks" id="benchmarks"></a>Benchmarks</h1>
+<p><strong>BENCHMARKS FOR COFFI AND DTYPE-NEXT ARE BASED ON AN OLD VERSION. NEW BENCHMARKS WILL BE CREATED SOON.</strong></p>
+<p>An additional consideration when thinking about alternatives is the performance of each available option. It’s an established fact that JNA (used by all three alternative libraries on JDK &lt;16) introduces more overhead when calling native code than JNI does.</p>
+<p>In order to provide a benchmark to see how much of a difference the different native interfaces make, we can use <a href="https://github.com/hugoduncan/criterium">criterium</a> to benchmark each. <a href="https://www.glfw.org">GLFW</a>’s <a href="https://www.glfw.org/docs/latest/group__input.html#gaa6cf4e7a77158a3b8fd00328b1720a4a"><code>glfwGetTime</code></a> function will be used for the test as it performs a simple operation, and is conveniently already wrapped in JNI by the excellent <a href="https://www.lwjgl.org/">LWJGL</a> library.</p>
+<p>The following benchmarks were run on a Lenovo Thinkpad with an Intel i7-10610U running Manjaro Linux, using Clojure 1.10.3 on Java 17.</p>
+<h3><a href="#jni" id="jni"></a>JNI</h3>
+<p>The baseline for performance is the JNI. Using LWJGL it’s relatively simple to benchmark. The following Clojure CLI command will start a repl with LWJGL and criterium loaded.</p>
+<pre><code class="language-sh">$ clj -Sdeps '{:deps {org.lwjgl/lwjgl {:mvn/version "3.2.3"}
+                      org.lwjgl/lwjgl-glfw {:mvn/version "3.2.3"}
+                      org.lwjgl/lwjgl$natives-linux {:mvn/version "3.2.3"}
+                      org.lwjgl/lwjgl-glfw$natives-linux {:mvn/version "3.2.3"}
+                      criterium/criterium {:mvn/version "0.4.6"}}}'
+</code></pre>
+<p>Then from the repl</p>
+<pre><code class="language-clojure">user=&gt; (import 'org.lwjgl.glfw.GLFW)
+org.lwjgl.glfw.GLFW
+user=&gt; (require '[criterium.core :as bench])
+nil
+user=&gt; (GLFW/glfwInit)
+true
+user=&gt; (bench/bench (GLFW/glfwGetTime) :verbose)
+amd64 Linux 5.10.68-1-MANJARO 8 cpu(s)
+OpenJDK 64-Bit Server VM 17+35-2724
+Runtime arguments: -Dclojure.basis=/home/jsusk/.clojure/.cpcache/2667074721.basis
+Evaluation count : 1613349900 in 60 samples of 26889165 calls.
+      Execution time sample mean : 32.698446 ns
+             Execution time mean : 32.697811 ns
+Execution time sample std-deviation : 1.274600 ns
+    Execution time std-deviation : 1.276437 ns
+   Execution time lower quantile : 30.750813 ns ( 2.5%)
+   Execution time upper quantile : 33.757662 ns (97.5%)
+                   Overhead used : 6.400704 ns
+nil
+</code></pre>
+<p>GLFW requires that we initialize it before calling the <code>glfwGetTime</code> function. Besides that this is a simple interop call which directly maps to the native function.</p>
+<p>This gives us a basis of 32.7 ns +/-1.3 ns. All other libraries will be evaluated relative to this result.</p>
+<p>To ensure fairness, we’ll also get that overhead value to be used in further tests.</p>
+<pre><code class="language-clojure">user=&gt; bench/estimated-overhead-cache
+6.400703613065185E-9
+</code></pre>
+<h3><a href="#coffi" id="coffi"></a>Coffi</h3>
+<p>The dependencies when using coffi are simpler, but it also requires some JVM options to support the foreign access api.</p>
+<pre><code class="language-sh">$ clj -Sdeps '{:deps {org.suskalo/coffi {:mvn/version "0.1.205"}
+                      criterium/criterium {:mvn/version "0.4.6"}}}' \
+      -J--add-modules=jdk.incubator.foreign \
+      -J--enable-native-access=ALL-UNNAMED
+</code></pre>
+<p>In order to ensure fair comparisons, we’re going to use the same overhead value on each run, so before we do the benchmark we’ll set it to the observed value from last time.</p>
+<pre><code class="language-clojure">user=&gt; (require '[criterium.core :as bench])
+nil
+user=&gt; (alter-var-root #'bench/estimated-overhead-cache (constantly 6.400703613065185E-9))
+6.400703613065185E-9
+user=&gt; (require '[coffi.ffi :as ffi])
+nil
+user=&gt; (require '[coffi.mem :as mem])
+nil
+user=&gt; (ffi/load-system-library "glfw")
+nil
+user=&gt; ((ffi/cfn "glfwInit" [] ::mem/int))
+1
+user=&gt; (let [f (ffi/cfn "glfwGetTime" [] ::mem/double)]
+         (bench/bench (f) :verbose))
+amd64 Linux 5.10.68-1-MANJARO 8 cpu(s)
+OpenJDK 64-Bit Server VM 17+35-2724
+Runtime arguments: --add-modules=jdk.incubator.foreign --enable-native-access=ALL-UNNAMED -Dclojure.basis=/home/jsusk/.clojure/.cpcache/72793624.basis
+Evaluation count : 1657995600 in 60 samples of 27633260 calls.
+      Execution time sample mean : 31.382665 ns
+             Execution time mean : 31.386493 ns
+Execution time sample std-deviation : 1.598571 ns
+    Execution time std-deviation : 1.608818 ns
+   Execution time lower quantile : 29.761194 ns ( 2.5%)
+   Execution time upper quantile : 33.228276 ns (97.5%)
+                   Overhead used : 6.400704 ns
+nil
+</code></pre>
+<p>This result is about 1.3 ns faster, and while that is less than the standard deviation of 1.6, it’s quite close to it.</p>
+<h3><a href="#clojure-jna" id="clojure-jna"></a>Clojure-JNA</h3>
+<p>Clojure-JNA uses the JNA library, which was designed to provide Java with an easy way to access native libraries, but which is known for not having the greatest performance. Since this is an older project, I’m also including the clojure dependency to ensure the correct version is used.</p>
+<pre><code class="language-sh">$ clj -Sdeps '{:deps {org.clojure/clojure {:mvn/version "1.10.3"}
+                      net.n01se/clojure-jna {:mvn/version "1.0.0"}
+                      criterium/criterium {:mvn/version "0.4.6"}}}'
+</code></pre>
+<p>The naive way to call the function using Clojure-JNA is to use <code>jna/invoke</code>.</p>
+<pre><code class="language-clojure">user=&gt; (require '[criterium.core :as bench])
+nil
+user=&gt; (alter-var-root #'bench/estimated-overhead-cache (constantly 6.400703613065185E-9))
+6.400703613065185E-9
+user=&gt; (require '[net.n01se.clojure-jna :as jna])
+nil
+user=&gt; (jna/invoke Integer glfw/glfwInit)
+1
+user=&gt; (bench/bench (jna/invoke Double glfw/glfwGetTime) :verbose)
+amd64 Linux 5.10.68-1-MANJARO 8 cpu(s)
+OpenJDK 64-Bit Server VM 17+35-2724
+Runtime arguments: -Dclojure.basis=/home/jsusk/.clojure/.cpcache/3229486237.basis
+Evaluation count : 195948720 in 60 samples of 3265812 calls.
+      Execution time sample mean : 350.335614 ns
+             Execution time mean : 350.373520 ns
+Execution time sample std-deviation : 24.833070 ns
+    Execution time std-deviation : 24.755929 ns
+   Execution time lower quantile : 300.000019 ns ( 2.5%)
+   Execution time upper quantile : 365.759273 ns (97.5%)
+                   Overhead used : 6.400704 ns
+
+Found 13 outliers in 60 samples (21.6667 %)
+	low-severe	 12 (20.0000 %)
+	low-mild	 1 (1.6667 %)
+ Variance from outliers : 53.4220 % Variance is severely inflated by outliers
+nil
+</code></pre>
+<p>As you can see, this method of calling functions is very bad for performance, with call overhead dominating function runtime by an order of magnitude. That said, this isn’t a completely fair comparison, nor the most realistic, because this way of calling functions looks the function up on each invocation.</p>
+<p>To adjust for this, we’ll use the <code>jna/to-fn</code> function to give a persistent handle to the function that we can call.</p>
+<pre><code class="language-clojure">user=&gt; (let [f (jna/to-fn Double glfw/glfwGetTime)]
+         (bench/bench (f) :verbose))
+amd64 Linux 5.10.68-1-MANJARO 8 cpu(s)
+OpenJDK 64-Bit Server VM 17+35-2724
+Runtime arguments: -Dclojure.basis=/home/jsusk/.clojure/.cpcache/3229486237.basis
+Evaluation count : 611095020 in 60 samples of 10184917 calls.
+      Execution time sample mean : 104.623634 ns
+             Execution time mean : 104.638406 ns
+Execution time sample std-deviation : 7.649296 ns
+    Execution time std-deviation : 7.638963 ns
+   Execution time lower quantile : 92.446016 ns ( 2.5%)
+   Execution time upper quantile : 110.258832 ns (97.5%)
+                   Overhead used : 6.400704 ns
+nil
+</code></pre>
+<p>This is much better, but is still about 3x slower than JNI, meaning the overhead from using JNA is still bigger than the function runtime.</p>
+<p>This performance penalty is still small in the scope of longer-running functions, and so may not be a concern for your application, but it is something to be aware of.</p>
+<h3><a href="#techjna" id="techjna"></a>tech.jna</h3>
+<p>The tech.jna library is similar in scope to Clojure-JNA, however was written to fit into an ecosystem of libraries meant for array-based programming for machine learning and data science.</p>
+<pre><code class="language-sh">$ clj -Sdeps '{:deps {techascent/tech.jna {:mvn/version "4.05"}
+                      criterium/criterium {:mvn/version "0.4.6"}}}'
+</code></pre>
+<p>This library is also quite simple to use, the only slightly odd thing I’m doing here is to dereference the var outside the benchmark in order to ensure it’s an apples-to-apples comparison. We don’t want var dereference time mucking up our benchmark.</p>
+<pre><code class="language-clojure">user=&gt; (require '[criterium.core :as bench])
+nil
+user=&gt; (alter-var-root #'bench/estimated-overhead-cache (constantly 6.400703613065185E-9))
+6.400703613065185E-9
+user=&gt; (require '[tech.v3.jna :as jna])
+nil
+user=&gt; (jna/def-jna-fn "glfw" glfwInit "initialize glfw" Integer)
+#'user/glfwInit
+user=&gt; (glfwInit)
+Oct 09, 2021 10:30:50 AM clojure.tools.logging$eval1122$fn__1125 invoke
+INFO: Library glfw found at [:system "glfw"]
+1
+user=&gt; (jna/def-jna-fn "glfw" glfwGetTime "gets the time as a double since init" Double)
+#'user/glfwGetTime
+user=&gt; (let [f @#'glfwGetTime]
+         (bench/bench (f) :verbose))
+amd64 Linux 5.10.68-1-MANJARO 8 cpu(s)
+OpenJDK 64-Bit Server VM 17+35-2724
+Runtime arguments: -Dclojure.basis=/home/jsusk/.clojure/.cpcache/2910209237.basis
+Evaluation count : 323281680 in 60 samples of 5388028 calls.
+      Execution time sample mean : 203.976803 ns
+             Execution time mean : 203.818712 ns
+Execution time sample std-deviation : 14.557312 ns
+    Execution time std-deviation : 14.614080 ns
+   Execution time lower quantile : 179.732593 ns ( 2.5%)
+   Execution time upper quantile : 213.929374 ns (97.5%)
+                   Overhead used : 6.400704 ns
+nil
+</code></pre>
+<p>This version is even slower than Clojure-JNA. I’m unsure where this overhead is coming from, but I’ll admit that I haven’t looked at their implementations very closely.</p>
+<h3><a href="#dtype-next" id="dtype-next"></a>dtype-next</h3>
+<p>The library dtype-next replaced tech.jna in the toolkit of the group working on machine learning and array-based programming, and it includes support for composite data types including structs, as well as primitive functions and callbacks.</p>
+<p>In addition, dtype-next has two different ffi backends. First is JNA, which is usable on any JDK version, and is what we’ll use for the first benchmark. Second is the Java 16 version of Project Panama, which will be shown next.</p>
+<p>In order to use the dtype-next ffi with the JNA backend, the JNA library has to be included in the dependencies.</p>
+<pre><code class="language-sh">$ clj -Sdeps '{:deps {cnuernber/dtype-next {:mvn/version "8.032"}
+                      net.java.dev.jna/jna {:mvn/version "5.8.0"}
+                      criterium/criterium {:mvn/version "0.4.6"}}}'
+</code></pre>
+<p>The dtype-next library also requires some more ceremony around declaring native functions. One advantage this has is that multiple symbols with the same name can be loaded from different shared libraries, but it also does increase friction when defining native wrappers.</p>
+<p>Some easier ways to define native wrappers are provided than what is seen here, but they share some disadvantages in documentation over the core methods provided in coffi, although they are comparable to the data model provided in coffi.</p>
+<pre><code class="language-clojure">user=&gt; (require '[criterium.core :as bench])
+nil
+user=&gt; (alter-var-root #'bench/estimated-overhead-cache (constantly 6.400703613065185E-9))
+6.400703613065185E-9
+user=&gt; (require '[tech.v3.datatype.ffi :as dt-ffi])
+nil
+user=&gt; (def fn-defs {:glfwInit {:rettype :int32} :glfwGetTime {:rettype :float64}})
+#'user/fn-defs
+user=&gt; (def library-def (dt-ffi/define-library fn-defs))
+#'user/library-def
+user=&gt; (def library-instance (dt-ffi/instantiate-library library-def "/usr/lib/libglfw.so"))
+#'user/library-instance
+user=&gt; (def init (:glfwInit @library-instance))
+#'user/init
+user=&gt; (init)
+1
+user=&gt; (let [f (:glfwGetTime @library-instance)]
+         (bench/bench (f) :verbose))
+amd64 Linux 5.10.68-1-MANJARO 8 cpu(s)
+OpenJDK 64-Bit Server VM 17+35-2724
+Runtime arguments: -Dclojure.basis=/home/jsusk/.clojure/.cpcache/643862289.basis
+Evaluation count : 710822100 in 60 samples of 11847035 calls.
+      Execution time sample mean : 90.900112 ns
+             Execution time mean : 90.919917 ns
+Execution time sample std-deviation : 6.463312 ns
+    Execution time std-deviation : 6.470108 ns
+   Execution time lower quantile : 79.817126 ns ( 2.5%)
+   Execution time upper quantile : 95.454652 ns (97.5%)
+                   Overhead used : 6.400704 ns
+nil
+</code></pre>
+<p>This version of JNA usage is significantly faster than either of the other JNA libraries, but is still substantially slower than using JNI or coffi.</p>
+<p>In addition to the JNA backend, dtype-next has a Java 16-specific backend that uses an older version of Panama. This version requires similar setup to coffi in order to run.</p>
+<pre><code class="language-sh">$ clj -Sdeps '{:deps {cnuernber/dtype-next {:mvn/version "8.032"}
+                      criterium/criterium {:mvn/version "0.4.6"}}}' \
+      -J--add-modules=jdk.incubator.foreign \
+      -J-Dforeign.restricted=permit \
+      -J--add-opens=java.base/java.lang=ALL-UNNAMED \
+      -J-Djava.library.path=/usr/lib/x86_64-linux-gnu
+</code></pre>
+<p>The actual code to run the benchmark is identical to the last example, but is reproduced here for completeness.</p>
+<pre><code class="language-clojure">user=&gt; (require '[criterium.core :as bench])
+nil
+user=&gt; (alter-var-root #'bench/estimated-overhead-cache (constantly 6.400703613065185E-9))
+6.400703613065185E-9
+user=&gt; (require '[tech.v3.datatype.ffi :as dt-ffi])
+nil
+user=&gt; (def fn-defs {:glfwInit {:rettype :int32} :glfwGetTime {:rettype :float64}})
+#'user/fn-defs
+user=&gt; (def library-def (dt-ffi/define-library fn-defs))
+#'user/library-def
+user=&gt; (def library-instance (dt-ffi/instantiate-library library-def "/usr/lib/libglfw.so"))
+#'user/library-instance
+user=&gt; (def init (:glfwInit @library-instance))
+#'user/init
+user=&gt; (init)
+1
+user=&gt; (let [f (:glfwGetTime @library-instance)]
+         (bench/bench (f) :verbose))
+amd64 Linux 5.10.68-1-MANJARO 8 cpu(s)
+OpenJDK 64-Bit Server VM 16.0.2+7
+Runtime arguments: --add-modules=jdk.incubator.foreign -Dforeign.restricted=permit --add-opens=java.base/java.lang=ALL-UNNAMED -Djava.library.path=/usr/lib/x86_64-linux-gnu -Dclojure.basis=/home/jsusk/.clojure/.cpcache/2337051659.basis
+Evaluation count : 1588513080 in 60 samples of 26475218 calls.
+      Execution time sample mean : 58.732468 ns
+             Execution time mean : 58.647361 ns
+Execution time sample std-deviation : 9.732389 ns
+    Execution time std-deviation : 9.791738 ns
+   Execution time lower quantile : 31.318115 ns ( 2.5%)
+   Execution time upper quantile : 65.449222 ns (97.5%)
+                   Overhead used : 6.400704 ns
+
+Found 14 outliers in 60 samples (23.3333 %)
+	low-severe	 8 (13.3333 %)
+	low-mild	 4 (6.6667 %)
+	high-mild	 2 (3.3333 %)
+ Variance from outliers : 87.6044 % Variance is severely inflated by outliers
+nil
+</code></pre>
+<p>Not reproduced here, but notable for comparison, in my testing Java 16’s version of the JNI version performed about the same.</p>
+<p>This is significantly faster than the JNA version of dtype-next, but it is still slower than modern Panama. This is likely to simply be a result of optimizations and changes to the Panama API, and when dtype-next is updated to use the Java 17 version of Panama I expect it will perform in line with coffi, but this benchmark will be reproduced when this happens. Still, this shows that as it stands, coffi is the fastest FFI available to Clojure developers.</p>
+</div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/articles/01-Getting-Started.md b/docs/articles/01-Getting-Started.md
index f190cc2..6fb3cc6 100644
--- a/docs/articles/01-Getting-Started.md
+++ b/docs/articles/01-Getting-Started.md
@@ -307,3 +307,37 @@ atomic semantics either.
 The memory that backs the static variable can be fetched with the function
 `static-variable-segment`, which can be used to pass a pointer to the static
 variable to native functions that require it.
+
+### Complex Wrappers
+Some functions require more complex code to map nicely to a Clojure function.
+The `defcfn` macro provides facilities to wrap the native function with some
+Clojure code to make this easier.
+
+```clojure
+(defcfn takes-array
+  "takes_array_with_count" [::mem/pointer ::mem/long] ::mem/void
+  native-fn
+  [ints]
+  (let [arr-len (count ints)
+        int-array (mem/serialize ints [::mem/array ::mem/int arr-len])]
+    (native-fn int-array arr-len)))
+```
+
+The symbol `native-fn` can be any unqualified symbol, and names the native
+function being wrapped. It must be called in the function body below if you want
+to call the native code.
+
+This `serialize` function has a paired `deserialize`, and allows marshaling
+Clojure data back and forth to native data structures.
+
+This can be used to implement out variables often seen in native code.
+
+```clojure
+(defcfn out-int
+  "out_int" [::mem/pointer] ::mem/void
+  native-fn
+  [i]
+  (let [int-ptr (mem/serialize i [::mem/pointer ::mem/int])]
+    (native-fn int-ptr)
+    (mem/deserialize int-ptr [::mem/pointer ::mem/int])))
+```
diff --git a/docs/articles/02-Memory-Management.md b/docs/articles/02-Memory-Management.md
new file mode 100644
index 0000000..2826d31
--- /dev/null
+++ b/docs/articles/02-Memory-Management.md
@@ -0,0 +1,38 @@
+# Memory Management
+In order to serialize any non-primitive type, off-heap memory needs to be
+allocated. When memory is allocated inside the JVM, the memory is associated
+with an arena. If none is provided, the arena is an implicit arena, and the
+memory will be freed when the serialized object is garbage collected.
+
+In many cases this is not desirable, because the memory is not freed in a
+deterministic manner, causing garbage collection pauses to become longer, as
+well as changing allocation performance. Instead of an implicit arena, there
+are other kinds of arenas as well. A `confined-arena` is a thread-local arena.
+Confined arenas are `Closeable`, which means they should usually be used in a
+`with-open` form. When a `confined-arena` is closed, it immediately frees all
+the memory associated with it. The previous example, `out-int`, can be
+implemented with a confined arena.
+
+```clojure
+(defcfn out-int
+  "out_int" [::mem/pointer] ::mem/void
+  native-fn
+  [i]
+  (with-open [arena (mem/confined-arena)]
+    (let [int-ptr (mem/serialize i [::mem/pointer ::mem/int] arena)]
+      (native-fn int-ptr)
+      (mem/deserialize int-ptr [::mem/pointer ::mem/int]))))
+```
+
+This will free the pointer immediately upon leaving the function.
+
+When memory needs to be accessible from multiple threads, there's
+`shared-arena`. When a `shared-arena` is `.close`d, it will release all its
+associated memory immediately, and so this should only be done once all other
+threads are done accessing memory associated with it.
+
+In addition, two non-`Closeable` arenas are `global-arena`, which never frees
+the resources associated with it, and `auto-arena`, which is an arena that frees
+its resources once all of them are unreachable during a garbage collection
+cycle, like an implicit arena, but potentially for multiple allocations rather
+than just one.
diff --git a/docs/articles/03-Builtin-Types.md b/docs/articles/03-Builtin-Types.md
new file mode 100644
index 0000000..81d8cfb
--- /dev/null
+++ b/docs/articles/03-Builtin-Types.md
@@ -0,0 +1,53 @@
+# Built-in Types
+
+### Primitives
+
+### Arrays
+
+### Pointers
+
+### Structs
+
+### Enums
+
+### Flagsets
+
+### Unions
+Unions in coffi are rather limited. They can be serialized, but not deserialized
+without external information.
+
+```clojure
+[::mem/union
+ #{::mem/float ::mem/double}
+ :dispatch #(cond
+             (float? %) ::mem/float
+             (double? %) ::mem/double)]
+```
+
+This is a minimal union in coffi. If the `:dispatch` keyword argument is not
+passed, then the union cannot be serialized, as coffi would not know which type
+to serialize the values as. In the example with a tagged union, a dispatch
+function was not provided because the type was only used for the native layout.
+
+In addition to a dispatch function, when serializing a union an extract function
+may also be provided. In the case of the value in the tagged union from before,
+it could be represented for serialization purposes like so:
+
+```clojure
+[::mem/union
+ #{::mem/int ::mem/c-string}
+ :dispatch #(case (first %)
+              :ok ::mem/int
+              :err ::mem/c-string)
+ :extract second]
+```
+
+This union however would not include the tag when serialized.
+
+If a union is deserialized, then all that coffi does is to allocate a new
+segment of the appropriate size with an implicit arena so that it may later be
+garbage collected, and copies the data from the source segment into it. It's up
+to the user to call `deserialize-from` on that segment with the appropriate
+type.
+
+### Raw Types
diff --git a/docs/articles/04-Custom-Types.md b/docs/articles/04-Custom-Types.md
new file mode 100644
index 0000000..e785d9d
--- /dev/null
+++ b/docs/articles/04-Custom-Types.md
@@ -0,0 +1,136 @@
+# Custom Types
+Custom types with serializers and deserializers may be created. This is done
+using two sets of three multimethods which can be extended by the user. For any
+given type, only one set need be implemented.
+
+Two examples of custom types are given here, one is a 3d vector, and the other
+an example of a tagged union.
+
+### Vector3
+For the vector type, it will serialize to a pointer to an array of three floats.
+
+The multimethod `primitive-type` returns the primitive type that a given type
+serializes to. For this example, it should be a pointer.
+
+```clojure
+(defmethod mem/primitive-type ::vector
+  [_type]
+  ::mem/pointer)
+```
+
+For any type which doesn't serialize to a primitive, it returns nil, and
+therefore need not be overriden.
+
+Next is `serialize*` and `deserialize*`, multimethods that work with types that
+serialize to primitives.
+
+```clojure
+(defmethod mem/serialize* ::vector
+  [obj _type arena]
+  (mem/serialize obj [::mem/array ::mem/float 3] arena))
+
+(defmethod mem/deserialize* ::vector
+  [segment _type]
+  (mem/deserialize (mem/reinterpret segment (mem/size-of [::mem/array ::mem/float 3]))
+                   [::mem/array ::mem/float 3]))
+```
+
+The `reinterpret` function allows you to take a segment and decorate it with a
+new size, and possibly associate it with an arena or add cleanup functions on
+it.
+
+In cases like this where we don't know the arena of the pointer, we could use
+`reinterpret` to ensure it's freed. For example if a `free-vector!` function
+that takes a pointer exists, we could use this:
+
+```clojure
+(defcfn returns-vector
+  "returns_vector" [] ::mem/pointer
+  native-fn
+  [arena]
+  (let [ret-ptr (native-fn)]
+    (-> (reinterpret ret-ptr (mem/size-of ::vector) arena free-vector!)
+        (deserialize ::vector))))
+```
+
+This function takes an arena and returns the deserialized vector, and it will
+free the pointer when the arena closes.
+
+### Tagged Union
+For the tagged union type, we will represent the value as a vector of a keyword
+naming the tag and the value. The type itself will need to take arguments,
+similar to `struct`. For example, if we were to represent a result type like in
+Rust, we might have the following values:
+
+```clojure
+[:ok 5]
+[:err "Invalid number format"]
+```
+
+To represent this, we can have a `tagged-union` type. For this instance of the
+result type, it may look like this:
+
+```clojure
+[::tagged-union [:ok :err] {:ok ::mem/int :err ::mem/c-string}]
+```
+
+The native representation of these objects is a struct of the tag and a union of
+the value. In order to correctly serialize the data and pass it to native code,
+we need a representation of the native layout of the data. The `c-layout`
+multimethod provides that.
+
+```clojure
+(defmethod mem/c-layout ::tagged-union
+  [[_tagged-union tags type-map]]
+  (mem/c-layout [::mem/struct
+                 [[:tag ::mem/long]
+                  [:value [::mem/union (vals type-map)]]]]))
+```
+
+Types with type arguments are represented as vectors of the type name and any
+additional arguments. The type name is what is dispatched on for the
+multimethods.
+
+Now that we have a native layout, we need to be able to serialize and
+deserialize the value into and out of memory segments. This is accomplished with
+`serialize-into` and `deserialize-from`.
+
+```clojure
+(defn item-index
+  "Gets the index of the first occurance of `item` in `coll`."
+  [coll item]
+  (first
+   (->> coll
+        (map-indexed vector)
+        (filter (comp #{item} second))
+        (map first))))
+
+(defmethod mem/serialize-into ::tagged-union
+  [obj [_tagged-union tags type-map] segment arena]
+  (mem/serialize-into
+   {:tag (item-index tags (first obj))
+    :value (second obj)}
+   [::mem/struct
+    [[:tag ::mem/long]
+     [:value (get type-map (first obj))]]]
+   segment
+   arena))
+```
+
+This serialization method is rather simple, it just turns the vector value into
+a map, and serializes it as a struct, choosing the type of the value based on
+the tag.
+
+```clojure
+(defmethod mem/deserialize-from ::tagged-union
+  [segment [_tagged-union tags type-map]]
+  (let [tag (mem/deserialize-from segment ::mem/long)]
+    [(nth tags tag)
+     (mem/deserialize-from
+      (mem/slice segment (mem/size-of ::mem/long))
+      (get type-map tag))]))
+```
+
+Deserialization is a little more complex. First the tag is retrieved from the
+beginning of the segment, and then the type of the value is decided based on
+that before it is deserialized.
diff --git a/docs/articles/05-Low-Level-Wrappers.md b/docs/articles/05-Low-Level-Wrappers.md
new file mode 100644
index 0000000..e0f131f
--- /dev/null
+++ b/docs/articles/05-Low-Level-Wrappers.md
@@ -0,0 +1,95 @@
+# Low-Level Wrappers
+
+### Unwrapped Native Handles
+Some native libraries work with handles to large amounts of data at once, making
+it undesirable to marshal data back and forth from Clojure, both because it's
+not necessary to work with the data in Clojure directly, or also because of the
+high (de)serialization costs associated with marshaling. In cases like these,
+unwrapped native handles are desirable.
+
+The functions `make-downcall` and `make-varargs-factory` are also provided to
+create raw function handles.
+
+```clojure
+(def raw-strlen (ffi/make-downcall "strlen" [::mem/c-string] ::mem/long))
+(raw-strlen (mem/serialize "hello" ::mem/c-string))
+;; => 5
+```
+
+With raw handles, the argument types are expected to exactly match the types
+expected by the native function. For primitive types, those are primitives. For
+pointers, that is `MemorySegment`, and for composite types like structs and
+unions, that is also `MemorySegment`. `MemorySegment` comes from the
+`java.lang.foreign` package.
+
+In addition, when a raw handle returns a composite type represented with a
+`MemorySegment`, it requires an additional first argument, a `SegmentAllocator`,
+which can be acquired with `arena-allocator` to get one associated with a
+specific arena. The returned value will live until that arena is released.
+
+In addition, function types can be specified as being raw, in the following
+manner:
+
+```clojure
+[::ffi/fn [::mem/int] ::mem/int :raw-fn? true]
+```
+
+Clojure functions serialized to this type will have their arguments and return
+value exactly match the types specified and will not perform any serialization
+or deserialization at their boundaries.
+
+One important caveat to consider when writing wrappers for performance-sensitive
+functions is that the convenience macro `defcfn` that coffi provides will
+already perform no serialization or deserialization on primitive arguments and
+return types, so for functions with only primitive argument and return types
+there is no performance reason to choose unwrapped native handles over the
+convenience macro.
+
+### Manual (De)Serialization
+Coffi uses multimethods to dispatch to (de)serialization functions to enable
+code that's generic over the types it operates on. However, in cases where you
+know the exact types that you will be (de)serializing and the multimethod
+dispatch overhead is too high a cost, it may be appropriate to manually handle
+(de)serializing data. This will often be done paired with [Unwrapped Native
+Handles](#unwrapped-native-handles).
+
+Convenience functions are provided to both read and write all primitive types
+and addresses, including byte order.
+
+As an example, when wrapping a function that returns an array of big-endian
+floats, the following code might be used.
+
+``` clojure
+;; int returns_float_array(float **arr)
+(def ^:private returns-float-array* (ffi/make-downcall "returns_float_array" [::mem/pointer] ::mem/int))
+;; void releases_float_array(float *arr)
+(def ^:private release-floats* (ffi/make-downcall "releases_float_array" [::mem/pointer] ::mem/void))
+
+(defn returns-float-array
+  []
+  (with-open [arena (mem/confined-arena)]
+    ;; float *out_floats;
+    ;; int num_floats = returns_float_array(&out_floats);
+    (let [out-floats (mem/alloc mem/pointer-size arena)
+          num-floats (returns-float-array* out-floats)
+          floats-addr (mem/read-address out-floats)
+          floats-slice (mem/reinterpret floats-addr (unchecked-multiply-int mem/float-size num-floats))]
+      ;; Using a try/finally to perform an operation when the stack frame exits,
+      ;; but not to try to catch anything.
+      (try
+        (loop [floats (transient [])
+               index 0]
+          (if (>= index num-floats)
+            (persistent! floats)
+            (recur (conj! floats (mem/read-float floats-slice
+                                                 (unchecked-multiply-int index mem/float-size)
+                                                 mem/big-endian))
+                   (unchecked-inc-int index))))
+        (finally
+          (release-floats* floats-addr))))))
+```
+
+The above code manually performs all memory operations rather than relying on
+coffi's dispatch. This will be more performant, but because multimethod overhead
+is usually relatively low, it's recommended to use the multimethod variants for
+convenience in colder functions.
diff --git a/docs/articles/50-Data-Model.md b/docs/articles/50-Data-Model.md
new file mode 100644
index 0000000..429255a
--- /dev/null
+++ b/docs/articles/50-Data-Model.md
@@ -0,0 +1,44 @@
+# Data Model
+In addition to the macros and functions provided to build a Clojure API for
+native libraries, facilities are provided for taking data and loading all the
+symbols specified by it. This can be useful if a library provides (or an
+external provider maintains) a data representation of their API, as Clojure data
+to represent it may be programmatically generated from these sources.
+
+The data to represent an API is a map with the following form:
+
+```clojure
+(def strlen-libspec
+  {:strlen {:type :function
+            :symbol "strlen"
+            :function/args [::mem/c-string]
+            :function/ret ::mem/long}})
+```
+
+Each key in this map represents a single symbol to be loaded. The value is a map
+with at least the keys `:type` and `:symbol`. These are the currently recognized
+types:
+
+- function
+- varargs-factory
+- const
+- static-var
+
+Each one has its own set of additional keys which can be added to the map. Both
+`function` and `varargs-factory` have the three keys `:function/args`,
+`:function/ret`, and `:function/raw-fn?`. The `const` type has `:const/type` and
+`static-var` has `:static-var/type`.
+
+This data can be passed to the function `reify-libspec`, which will take the
+data and return a map from the same keys as the input map to whatever value is
+appropriate for a given symbol type (e.g. a Clojure function for `function`, a
+value for `const`, etc.).
+
+```clojure
+(ffi/reify-libspec strlen-libspec)
+;; => {:strlen #function[...]}
+```
+
+This functionality can be extended by specifying new types as implementations of
+the multimethod `reify-symbolspec`, although it's recommended that for any
+library authors who do so, namespaced keywords be used to name types.
diff --git a/docs/articles/99-Benchmarks.md b/docs/articles/99-Benchmarks.md
new file mode 100644
index 0000000..69ef11c
--- /dev/null
+++ b/docs/articles/99-Benchmarks.md
@@ -0,0 +1,373 @@
+# Benchmarks
+**BENCHMARKS FOR COFFI AND DTYPE-NEXT ARE BASED ON AN OLD VERSION. NEW BENCHMARKS WILL BE CREATED SOON.**
+
+An additional consideration when thinking about alternatives is the performance
+of each available option. It's an established fact that JNA (used by all three
+alternative libraries on JDK <16) introduces more overhead when calling native
+code than JNI does.
+
+In order to provide a benchmark to see how much of a difference the different
+native interfaces make, we can use
+[criterium](https://github.com/hugoduncan/criterium) to benchmark each.
+[GLFW](https://www.glfw.org)'s
+[`glfwGetTime`](https://www.glfw.org/docs/latest/group__input.html#gaa6cf4e7a77158a3b8fd00328b1720a4a)
+function will be used for the test as it performs a simple operation, and is
+conveniently already wrapped in JNI by the excellent
+[LWJGL](https://www.lwjgl.org/) library.
+
+The following benchmarks were run on a Lenovo Thinkpad with an Intel i7-10610U
+running Manjaro Linux, using Clojure 1.10.3 on Java 17.
+
+### JNI
+The baseline for performance is the JNI. Using LWJGL it's relatively simple to
+benchmark. The following Clojure CLI command will start a repl with LWJGL and
+criterium loaded.
+
+```sh
+$ clj -Sdeps '{:deps {org.lwjgl/lwjgl {:mvn/version "3.2.3"}
+                      org.lwjgl/lwjgl-glfw {:mvn/version "3.2.3"}
+                      org.lwjgl/lwjgl$natives-linux {:mvn/version "3.2.3"}
+                      org.lwjgl/lwjgl-glfw$natives-linux {:mvn/version "3.2.3"}
+                      criterium/criterium {:mvn/version "0.4.6"}}}'
+```
+
+Then from the repl
+
+```clojure
+user=> (import 'org.lwjgl.glfw.GLFW)
+org.lwjgl.glfw.GLFW
+user=> (require '[criterium.core :as bench])
+nil
+user=> (GLFW/glfwInit)
+true
+user=> (bench/bench (GLFW/glfwGetTime) :verbose)
+amd64 Linux 5.10.68-1-MANJARO 8 cpu(s)
+OpenJDK 64-Bit Server VM 17+35-2724
+Runtime arguments: -Dclojure.basis=/home/jsusk/.clojure/.cpcache/2667074721.basis
+Evaluation count : 1613349900 in 60 samples of 26889165 calls.
+      Execution time sample mean : 32.698446 ns
+             Execution time mean : 32.697811 ns
+Execution time sample std-deviation : 1.274600 ns
+    Execution time std-deviation : 1.276437 ns
+   Execution time lower quantile : 30.750813 ns ( 2.5%)
+   Execution time upper quantile : 33.757662 ns (97.5%)
+                   Overhead used : 6.400704 ns
+nil
+```
+
+GLFW requires that we initialize it before calling the `glfwGetTime` function.
+Besides that this is a simple interop call which directly maps to the native
+function.
+
+This gives us a basis of 32.7 ns +/-1.3 ns. All other libraries will be
+evaluated relative to this result.
+
+To ensure fairness, we'll also get that overhead value to be used in further
+tests.
+
+```clojure
+user=> bench/estimated-overhead-cache
+6.400703613065185E-9
+```
+
+### Coffi
+The dependencies when using coffi are simpler, but it also requires some JVM
+options to support the foreign access api.
+
+```sh
+$ clj -Sdeps '{:deps {org.suskalo/coffi {:mvn/version "0.1.205"}
+                      criterium/criterium {:mvn/version "0.4.6"}}}' \
+      -J--add-modules=jdk.incubator.foreign \
+      -J--enable-native-access=ALL-UNNAMED
+```
+
+In order to ensure fair comparisons, we're going to use the same overhead value
+on each run, so before we do the benchmark we'll set it to the observed value
+from last time.
+
+```clojure
+user=> (require '[criterium.core :as bench])
+nil
+user=> (alter-var-root #'bench/estimated-overhead-cache (constantly 6.400703613065185E-9))
+6.400703613065185E-9
+user=> (require '[coffi.ffi :as ffi])
+nil
+user=> (require '[coffi.mem :as mem])
+nil
+user=> (ffi/load-system-library "glfw")
+nil
+user=> ((ffi/cfn "glfwInit" [] ::mem/int))
+1
+user=> (let [f (ffi/cfn "glfwGetTime" [] ::mem/double)]
+         (bench/bench (f) :verbose))
+amd64 Linux 5.10.68-1-MANJARO 8 cpu(s)
+OpenJDK 64-Bit Server VM 17+35-2724
+Runtime arguments: --add-modules=jdk.incubator.foreign --enable-native-access=ALL-UNNAMED -Dclojure.basis=/home/jsusk/.clojure/.cpcache/72793624.basis
+Evaluation count : 1657995600 in 60 samples of 27633260 calls.
+      Execution time sample mean : 31.382665 ns
+             Execution time mean : 31.386493 ns
+Execution time sample std-deviation : 1.598571 ns
+    Execution time std-deviation : 1.608818 ns
+   Execution time lower quantile : 29.761194 ns ( 2.5%)
+   Execution time upper quantile : 33.228276 ns (97.5%)
+                   Overhead used : 6.400704 ns
+nil
+```
+
+This result is about 1.3 ns faster, and while that is less than the standard
+deviation of 1.6, it's quite close to it.
+
+### Clojure-JNA
+Clojure-JNA uses the JNA library, which was designed to provide Java with an
+easy way to access native libraries, but which is known for not having the
+greatest performance. Since this is an older project, I'm also including the
+clojure dependency to ensure the correct version is used.
+
+```sh
+$ clj -Sdeps '{:deps {org.clojure/clojure {:mvn/version "1.10.3"}
+                      net.n01se/clojure-jna {:mvn/version "1.0.0"}
+                      criterium/criterium {:mvn/version "0.4.6"}}}'
+```
+
+The naive way to call the function using Clojure-JNA is to use `jna/invoke`.
+
+```clojure
+user=> (require '[criterium.core :as bench])
+nil
+user=> (alter-var-root #'bench/estimated-overhead-cache (constantly 6.400703613065185E-9))
+6.400703613065185E-9
+user=> (require '[net.n01se.clojure-jna :as jna])
+nil
+user=> (jna/invoke Integer glfw/glfwInit)
+1
+user=> (bench/bench (jna/invoke Double glfw/glfwGetTime) :verbose)
+amd64 Linux 5.10.68-1-MANJARO 8 cpu(s)
+OpenJDK 64-Bit Server VM 17+35-2724
+Runtime arguments: -Dclojure.basis=/home/jsusk/.clojure/.cpcache/3229486237.basis
+Evaluation count : 195948720 in 60 samples of 3265812 calls.
+      Execution time sample mean : 350.335614 ns
+             Execution time mean : 350.373520 ns
+Execution time sample std-deviation : 24.833070 ns
+    Execution time std-deviation : 24.755929 ns
+   Execution time lower quantile : 300.000019 ns ( 2.5%)
+   Execution time upper quantile : 365.759273 ns (97.5%)
+                   Overhead used : 6.400704 ns
+
+Found 13 outliers in 60 samples (21.6667 %)
+	low-severe	 12 (20.0000 %)
+	low-mild	 1 (1.6667 %)
+ Variance from outliers : 53.4220 % Variance is severely inflated by outliers
+nil
+```
+
+As you can see, this method of calling functions is very bad for performance,
+with call overhead dominating function runtime by an order of magnitude. That
+said, this isn't a completely fair comparison, nor the most realistic, because
+this way of calling functions looks the function up on each invocation.
+
+To adjust for this, we'll use the `jna/to-fn` function to give a persistent
+handle to the function that we can call.
+
+```clojure
+user=> (let [f (jna/to-fn Double glfw/glfwGetTime)]
+         (bench/bench (f) :verbose))
+amd64 Linux 5.10.68-1-MANJARO 8 cpu(s)
+OpenJDK 64-Bit Server VM 17+35-2724
+Runtime arguments: -Dclojure.basis=/home/jsusk/.clojure/.cpcache/3229486237.basis
+Evaluation count : 611095020 in 60 samples of 10184917 calls.
+      Execution time sample mean : 104.623634 ns
+             Execution time mean : 104.638406 ns
+Execution time sample std-deviation : 7.649296 ns
+    Execution time std-deviation : 7.638963 ns
+   Execution time lower quantile : 92.446016 ns ( 2.5%)
+   Execution time upper quantile : 110.258832 ns (97.5%)
+                   Overhead used : 6.400704 ns
+nil
+```
+
+This is much better, but is still about 3x slower than JNI, meaning the overhead
+from using JNA is still bigger than the function runtime.
+
+This performance penalty is still small in the scope of longer-running
+functions, and so may not be a concern for your application, but it is something
+to be aware of.
+
+### tech.jna
+The tech.jna library is similar in scope to Clojure-JNA, however was written to
+fit into an ecosystem of libraries meant for array-based programming for machine
+learning and data science.
+
+```sh
+$ clj -Sdeps '{:deps {techascent/tech.jna {:mvn/version "4.05"}
+                      criterium/criterium {:mvn/version "0.4.6"}}}'
+```
+
+This library is also quite simple to use, the only slightly odd thing I'm doing
+here is to dereference the var outside the benchmark in order to ensure it's an
+apples-to-apples comparison. We don't want var dereference time mucking up our
+benchmark.
+
+```clojure
+user=> (require '[criterium.core :as bench])
+nil
+user=> (alter-var-root #'bench/estimated-overhead-cache (constantly 6.400703613065185E-9))
+6.400703613065185E-9
+user=> (require '[tech.v3.jna :as jna])
+nil
+user=> (jna/def-jna-fn "glfw" glfwInit "initialize glfw" Integer)
+#'user/glfwInit
+user=> (glfwInit)
+Oct 09, 2021 10:30:50 AM clojure.tools.logging$eval1122$fn__1125 invoke
+INFO: Library glfw found at [:system "glfw"]
+1
+user=> (jna/def-jna-fn "glfw" glfwGetTime "gets the time as a double since init" Double)
+#'user/glfwGetTime
+user=> (let [f @#'glfwGetTime]
+         (bench/bench (f) :verbose))
+amd64 Linux 5.10.68-1-MANJARO 8 cpu(s)
+OpenJDK 64-Bit Server VM 17+35-2724
+Runtime arguments: -Dclojure.basis=/home/jsusk/.clojure/.cpcache/2910209237.basis
+Evaluation count : 323281680 in 60 samples of 5388028 calls.
+      Execution time sample mean : 203.976803 ns
+             Execution time mean : 203.818712 ns
+Execution time sample std-deviation : 14.557312 ns
+    Execution time std-deviation : 14.614080 ns
+   Execution time lower quantile : 179.732593 ns ( 2.5%)
+   Execution time upper quantile : 213.929374 ns (97.5%)
+                   Overhead used : 6.400704 ns
+nil
+```
+
+This version is even slower than Clojure-JNA. I'm unsure where this overhead is
+coming from, but I'll admit that I haven't looked at their implementations very
+closely.
+
+### dtype-next
+The library dtype-next replaced tech.jna in the toolkit of the group working on
+machine learning and array-based programming, and it includes support for
+composite data types including structs, as well as primitive functions and
+callbacks.
+
+In addition, dtype-next has two different ffi backends. First is JNA, which is
+usable on any JDK version, and is what we'll use for the first benchmark. Second
+is the Java 16 version of Project Panama, which will be shown next.
+
+In order to use the dtype-next ffi with the JNA backend, the JNA library has to
+be included in the dependencies.
+
+```sh
+$ clj -Sdeps '{:deps {cnuernber/dtype-next {:mvn/version "8.032"}
+                      net.java.dev.jna/jna {:mvn/version "5.8.0"}
+                      criterium/criterium {:mvn/version "0.4.6"}}}'
+```
+
+The dtype-next library also requires some more ceremony around declaring native
+functions. One advantage this has is that multiple symbols with the same name
+can be loaded from different shared libraries, but it also does increase
+friction when defining native wrappers.
+
+Some easier ways to define native wrappers are provided than what is seen here,
+but they share some disadvantages in documentation over the core methods
+provided in coffi, although they are comparable to the data model provided in
+coffi.
+
+```clojure
+user=> (require '[criterium.core :as bench])
+nil
+user=> (alter-var-root #'bench/estimated-overhead-cache (constantly 6.400703613065185E-9))
+6.400703613065185E-9
+user=> (require '[tech.v3.datatype.ffi :as dt-ffi])
+nil
+user=> (def fn-defs {:glfwInit {:rettype :int32} :glfwGetTime {:rettype :float64}})
+#'user/fn-defs
+user=> (def library-def (dt-ffi/define-library fn-defs))
+#'user/library-def
+user=> (def library-instance (dt-ffi/instantiate-library library-def "/usr/lib/libglfw.so"))
+#'user/library-instance
+user=> (def init (:glfwInit @library-instance))
+#'user/init
+user=> (init)
+1
+user=> (let [f (:glfwGetTime @library-instance)]
+         (bench/bench (f) :verbose))
+amd64 Linux 5.10.68-1-MANJARO 8 cpu(s)
+OpenJDK 64-Bit Server VM 17+35-2724
+Runtime arguments: -Dclojure.basis=/home/jsusk/.clojure/.cpcache/643862289.basis
+Evaluation count : 710822100 in 60 samples of 11847035 calls.
+      Execution time sample mean : 90.900112 ns
+             Execution time mean : 90.919917 ns
+Execution time sample std-deviation : 6.463312 ns
+    Execution time std-deviation : 6.470108 ns
+   Execution time lower quantile : 79.817126 ns ( 2.5%)
+   Execution time upper quantile : 95.454652 ns (97.5%)
+                   Overhead used : 6.400704 ns
+nil
+```
+
+This version of JNA usage is significantly faster than either of the other JNA
+libraries, but is still substantially slower than using JNI or coffi.
+
+In addition to the JNA backend, dtype-next has a Java 16-specific backend that
+uses an older version of Panama. This version requires similar setup to coffi in
+order to run.
+
+```sh
+$ clj -Sdeps '{:deps {cnuernber/dtype-next {:mvn/version "8.032"}
+                      criterium/criterium {:mvn/version "0.4.6"}}}' \
+      -J--add-modules=jdk.incubator.foreign \
+      -J-Dforeign.restricted=permit \
+      -J--add-opens=java.base/java.lang=ALL-UNNAMED \
+      -J-Djava.library.path=/usr/lib/x86_64-linux-gnu
+```
+
+The actual code to run the benchmark is identical to the last example, but is
+reproduced here for completeness.
+
+```clojure
+user=> (require '[criterium.core :as bench])
+nil
+user=> (alter-var-root #'bench/estimated-overhead-cache (constantly 6.400703613065185E-9))
+6.400703613065185E-9
+user=> (require '[tech.v3.datatype.ffi :as dt-ffi])
+nil
+user=> (def fn-defs {:glfwInit {:rettype :int32} :glfwGetTime {:rettype :float64}})
+#'user/fn-defs
+user=> (def library-def (dt-ffi/define-library fn-defs))
+#'user/library-def
+user=> (def library-instance (dt-ffi/instantiate-library library-def "/usr/lib/libglfw.so"))
+#'user/library-instance
+user=> (def init (:glfwInit @library-instance))
+#'user/init
+user=> (init)
+1
+user=> (let [f (:glfwGetTime @library-instance)]
+         (bench/bench (f) :verbose))
+amd64 Linux 5.10.68-1-MANJARO 8 cpu(s)
+OpenJDK 64-Bit Server VM 16.0.2+7
+Runtime arguments: --add-modules=jdk.incubator.foreign -Dforeign.restricted=permit --add-opens=java.base/java.lang=ALL-UNNAMED -Djava.library.path=/usr/lib/x86_64-linux-gnu -Dclojure.basis=/home/jsusk/.clojure/.cpcache/2337051659.basis
+Evaluation count : 1588513080 in 60 samples of 26475218 calls.
+      Execution time sample mean : 58.732468 ns
+             Execution time mean : 58.647361 ns
+Execution time sample std-deviation : 9.732389 ns
+    Execution time std-deviation : 9.791738 ns
+   Execution time lower quantile : 31.318115 ns ( 2.5%)
+   Execution time upper quantile : 65.449222 ns (97.5%)
+                   Overhead used : 6.400704 ns
+
+Found 14 outliers in 60 samples (23.3333 %)
+	low-severe	 8 (13.3333 %)
+	low-mild	 4 (6.6667 %)
+	high-mild	 2 (3.3333 %)
+ Variance from outliers : 87.6044 % Variance is severely inflated by outliers
+nil
+```
+
+Not reproduced here, but notable for comparison, in my testing Java 16's version
+of the JNI version performed about the same.
+
+This is significantly faster than the JNA version of dtype-next, but it is still
+slower than modern Panama. This is likely to simply be a result of optimizations
+and changes to the Panama API, and when dtype-next is updated to use the Java 17
+version of Panama I expect it will perform in line with coffi, but this
+benchmark will be reproduced when this happens. Still, this shows that as it
+stands, coffi is the fastest FFI available to Clojure developers.
diff --git a/docs/coffi.ffi.html b/docs/coffi.ffi.html
index 7cc8c2c..c911409 100644
--- a/docs/coffi.ffi.html
+++ b/docs/coffi.ffi.html
@@ -1,41 +1,41 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>coffi.ffi documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch current"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="coffi.ffi.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-const"><div class="inner"><span>const</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-defcfn"><div class="inner"><span>defcfn</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-defconst"><div class="inner"><span>defconst</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-defvar"><div class="inner"><span>defvar</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-ensure-symbol"><div class="inner"><span>ensure-symbol</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-find-symbol"><div class="inner"><span>find-symbol</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-freset.21"><div class="inner"><span>freset!</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-fswap.21"><div class="inner"><span>fswap!</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-load-library"><div class="inner"><span>load-library</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-load-system-library"><div class="inner"><span>load-system-library</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-make-downcall"><div class="inner"><span>make-downcall</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-make-serde-varargs-wrapper"><div class="inner"><span>make-serde-varargs-wrapper</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-make-serde-wrapper"><div class="inner"><span>make-serde-wrapper</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-make-varargs-factory"><div class="inner"><span>make-varargs-factory</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-reify-libspec"><div class="inner"><span>reify-libspec</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-reify-symbolspec"><div class="inner"><span>reify-symbolspec</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-static-variable"><div class="inner"><span>static-variable</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-static-variable-segment"><div class="inner"><span>static-variable-segment</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-vacfn-factory"><div class="inner"><span>vacfn-factory</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">coffi.ffi</h1><div class="doc"><div class="markdown"><p>Functions for creating handles to native functions and loading native libraries.</p>
+<html><head><meta charset="UTF-8" /><title>coffi.ffi documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li><li class="depth-1 "><a href="02-Memory-Management.html"><div class="inner"><span>Memory Management</span></div></a></li><li class="depth-1 "><a href="03-Builtin-Types.html"><div class="inner"><span>Built-in Types</span></div></a></li><li class="depth-1 "><a href="04-Custom-Types.html"><div class="inner"><span>Custom Types</span></div></a></li><li class="depth-1 "><a href="05-Low-Level-Wrappers.html"><div class="inner"><span>Low-Level Wrappers</span></div></a></li><li class="depth-1 "><a href="50-Data-Model.html"><div class="inner"><span>Data Model</span></div></a></li><li class="depth-1 "><a href="99-Benchmarks.html"><div class="inner"><span>Benchmarks</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch current"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="coffi.ffi.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-const"><div class="inner"><span>const</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-defcfn"><div class="inner"><span>defcfn</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-defconst"><div class="inner"><span>defconst</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-defvar"><div class="inner"><span>defvar</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-ensure-symbol"><div class="inner"><span>ensure-symbol</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-find-symbol"><div class="inner"><span>find-symbol</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-freset.21"><div class="inner"><span>freset!</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-fswap.21"><div class="inner"><span>fswap!</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-load-library"><div class="inner"><span>load-library</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-load-system-library"><div class="inner"><span>load-system-library</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-make-downcall"><div class="inner"><span>make-downcall</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-make-serde-varargs-wrapper"><div class="inner"><span>make-serde-varargs-wrapper</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-make-serde-wrapper"><div class="inner"><span>make-serde-wrapper</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-make-varargs-factory"><div class="inner"><span>make-varargs-factory</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-reify-libspec"><div class="inner"><span>reify-libspec</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-reify-symbolspec"><div class="inner"><span>reify-symbolspec</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-static-variable"><div class="inner"><span>static-variable</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-static-variable-segment"><div class="inner"><span>static-variable-segment</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-vacfn-factory"><div class="inner"><span>vacfn-factory</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">coffi.ffi</h1><div class="doc"><div class="markdown"><p>Functions for creating handles to native functions and loading native libraries.</p>
 </div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn symbol args ret)</code></div><div class="doc"><div class="markdown"><p>Constructs a Clojure function to call the native function referenced by <code>symbol</code>.</p>
 <p>The function returned will serialize any passed arguments into the <code>args</code> types, and deserialize the return to the <code>ret</code> type.</p>
 <p>If your <code>args</code> and <code>ret</code> are constants, then it is more efficient to call <a href="coffi.ffi.html#var-make-downcall">make-downcall</a> followed by <a href="coffi.ffi.html#var-make-serde-wrapper">make-serde-wrapper</a> because the latter has an inline definition which will result in less overhead from serdes.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/ffi.clj#L438">view source</a></div></div><div class="public anchor" id="var-const"><h3>const</h3><div class="usage"><code>(const symbol-or-addr type)</code></div><div class="doc"><div class="markdown"><p>Gets the value of a constant stored in <code>symbol-or-addr</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/ffi.clj#L606">view source</a></div></div><div class="public anchor" id="var-defcfn"><h3>defcfn</h3><h4 class="type">macro</h4><div class="usage"><code>(defcfn name docstring? attr-map? symbol arg-types ret-type)</code><code>(defcfn name docstring? attr-map? symbol arg-types ret-type native-fn &amp; fn-tail)</code></div><div class="doc"><div class="markdown"><p>Defines a Clojure function which maps to a native function.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/ffi.clj#L438">view source</a></div></div><div class="public anchor" id="var-const"><h3>const</h3><div class="usage"><code>(const symbol-or-addr type)</code></div><div class="doc"><div class="markdown"><p>Gets the value of a constant stored in <code>symbol-or-addr</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/ffi.clj#L606">view source</a></div></div><div class="public anchor" id="var-defcfn"><h3>defcfn</h3><h4 class="type">macro</h4><div class="usage"><code>(defcfn name docstring? attr-map? symbol arg-types ret-type)</code><code>(defcfn name docstring? attr-map? symbol arg-types ret-type native-fn &amp; fn-tail)</code></div><div class="doc"><div class="markdown"><p>Defines a Clojure function which maps to a native function.</p>
 <p><code>name</code> is the symbol naming the resulting var. <code>symbol</code> is a symbol or string naming the library symbol to link against. <code>arg-types</code> is a vector of qualified keywords representing the argument types. <code>ret-type</code> is a single qualified keyword representing the return type. <code>fn-tail</code> is the body of the function (potentially with multiple arities) which wraps the native one. Inside the function, <code>native-fn</code> is bound to a function that will serialize its arguments, call the native function, and deserialize its return type. If any body is present, you must call this function in order to call the native code.</p>
 <p>If no <code>fn-tail</code> is provided, then the resulting function will simply serialize the arguments according to <code>arg-types</code>, call the native function, and deserialize the return value.</p>
 <p>The number of args in the <code>fn-tail</code> need not match the number of <code>arg-types</code> for the native function. It need only call the native wrapper function with the correct arguments.</p>
 <p>See <a href="coffi.mem.html#var-serialize">serialize</a>, <a href="coffi.mem.html#var-deserialize">deserialize</a>, <a href="coffi.ffi.html#var-make-downcall">make-downcall</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/ffi.clj#L780">view source</a></div></div><div class="public anchor" id="var-defconst"><h3>defconst</h3><h4 class="type">macro</h4><div class="usage"><code>(defconst symbol docstring? symbol-or-addr type)</code></div><div class="doc"><div class="markdown"><p>Defines a var named by <code>symbol</code> to be the value of the given <code>type</code> from <code>symbol-or-addr</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/ffi.clj#L617">view source</a></div></div><div class="public anchor" id="var-defvar"><h3>defvar</h3><h4 class="type">macro</h4><div class="usage"><code>(defvar symbol docstring? symbol-or-addr type)</code></div><div class="doc"><div class="markdown"><p>Defines a var named by <code>symbol</code> to be a reference to the native memory from <code>symbol-or-addr</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/ffi.clj#L683">view source</a></div></div><div class="public anchor" id="var-ensure-symbol"><h3>ensure-symbol</h3><div class="usage"><code>(ensure-symbol symbol-or-addr)</code></div><div class="doc"><div class="markdown"><p>Returns the argument if it is a <a href="null">MemorySegment</a>, otherwise calls <a href="coffi.ffi.html#var-find-symbol">find-symbol</a> on it.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/ffi.clj#L198">view source</a></div></div><div class="public anchor" id="var-find-symbol"><h3>find-symbol</h3><div class="usage"><code>(find-symbol sym)</code></div><div class="doc"><div class="markdown"><p>Gets the <a href="null">MemorySegment</a> of a symbol from the loaded libraries.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/ffi.clj#L38">view source</a></div></div><div class="public anchor" id="var-freset.21"><h3>freset!</h3><div class="usage"><code>(freset! static-var newval)</code></div><div class="doc"><div class="markdown"><p>Sets the value of <code>static-var</code> to <code>newval</code>, running it through <a href="coffi.mem.html#var-serialize">serialize</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/ffi.clj#L647">view source</a></div></div><div class="public anchor" id="var-fswap.21"><h3>fswap!</h3><div class="usage"><code>(fswap! static-var f &amp; args)</code></div><div class="doc"><div class="markdown"><p>Non-atomically runs the function <code>f</code> over the value stored in <code>static-var</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/ffi.clj#L780">view source</a></div></div><div class="public anchor" id="var-defconst"><h3>defconst</h3><h4 class="type">macro</h4><div class="usage"><code>(defconst symbol docstring? symbol-or-addr type)</code></div><div class="doc"><div class="markdown"><p>Defines a var named by <code>symbol</code> to be the value of the given <code>type</code> from <code>symbol-or-addr</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/ffi.clj#L617">view source</a></div></div><div class="public anchor" id="var-defvar"><h3>defvar</h3><h4 class="type">macro</h4><div class="usage"><code>(defvar symbol docstring? symbol-or-addr type)</code></div><div class="doc"><div class="markdown"><p>Defines a var named by <code>symbol</code> to be a reference to the native memory from <code>symbol-or-addr</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/ffi.clj#L683">view source</a></div></div><div class="public anchor" id="var-ensure-symbol"><h3>ensure-symbol</h3><div class="usage"><code>(ensure-symbol symbol-or-addr)</code></div><div class="doc"><div class="markdown"><p>Returns the argument if it is a <a href="null">MemorySegment</a>, otherwise calls <a href="coffi.ffi.html#var-find-symbol">find-symbol</a> on it.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/ffi.clj#L198">view source</a></div></div><div class="public anchor" id="var-find-symbol"><h3>find-symbol</h3><div class="usage"><code>(find-symbol sym)</code></div><div class="doc"><div class="markdown"><p>Gets the <a href="null">MemorySegment</a> of a symbol from the loaded libraries.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/ffi.clj#L38">view source</a></div></div><div class="public anchor" id="var-freset.21"><h3>freset!</h3><div class="usage"><code>(freset! static-var newval)</code></div><div class="doc"><div class="markdown"><p>Sets the value of <code>static-var</code> to <code>newval</code>, running it through <a href="coffi.mem.html#var-serialize">serialize</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/ffi.clj#L647">view source</a></div></div><div class="public anchor" id="var-fswap.21"><h3>fswap!</h3><div class="usage"><code>(fswap! static-var f &amp; args)</code></div><div class="doc"><div class="markdown"><p>Non-atomically runs the function <code>f</code> over the value stored in <code>static-var</code>.</p>
 <p>The value is deserialized before passing it to <code>f</code>, and serialized before putting the value into <code>static-var</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/ffi.clj#L656">view source</a></div></div><div class="public anchor" id="var-load-library"><h3>load-library</h3><div class="usage"><code>(load-library path)</code></div><div class="doc"><div class="markdown"><p>Loads the library at <code>path</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/ffi.clj#L33">view source</a></div></div><div class="public anchor" id="var-load-system-library"><h3>load-system-library</h3><div class="usage"><code>(load-system-library libname)</code></div><div class="doc"><div class="markdown"><p>Loads the library named <code>libname</code> from the system’s load path.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/ffi.clj#L28">view source</a></div></div><div class="public anchor" id="var-make-downcall"><h3>make-downcall</h3><div class="usage"><code>(make-downcall symbol-or-addr args ret)</code></div><div class="doc"><div class="markdown"><p>Constructs a downcall function reference to <code>symbol-or-addr</code> with the given <code>args</code> and <code>ret</code> types.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/ffi.clj#L656">view source</a></div></div><div class="public anchor" id="var-load-library"><h3>load-library</h3><div class="usage"><code>(load-library path)</code></div><div class="doc"><div class="markdown"><p>Loads the library at <code>path</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/ffi.clj#L33">view source</a></div></div><div class="public anchor" id="var-load-system-library"><h3>load-system-library</h3><div class="usage"><code>(load-system-library libname)</code></div><div class="doc"><div class="markdown"><p>Loads the library named <code>libname</code> from the system’s load path.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/ffi.clj#L28">view source</a></div></div><div class="public anchor" id="var-make-downcall"><h3>make-downcall</h3><div class="usage"><code>(make-downcall symbol-or-addr args ret)</code></div><div class="doc"><div class="markdown"><p>Constructs a downcall function reference to <code>symbol-or-addr</code> with the given <code>args</code> and <code>ret</code> types.</p>
 <p>The function returned takes only arguments whose types match exactly the <a href="coffi.mem.html#var-java-layout">java-layout</a> for that type, and returns an argument with exactly the <a href="coffi.mem.html#var-java-layout">java-layout</a> of the <code>ret</code> type. This function will perform no serialization or deserialization of arguments or the return type.</p>
 <p>If the <code>ret</code> type is non-primitive, then the returned function will take a first argument of a <a href="null">SegmentAllocator</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/ffi.clj#L206">view source</a></div></div><div class="public anchor" id="var-make-serde-varargs-wrapper"><h3>make-serde-varargs-wrapper</h3><div class="usage"><code>(make-serde-varargs-wrapper varargs-factory required-args ret-type)</code></div><div class="doc"><div class="markdown"><p>Constructs a wrapper function for the <code>varargs-factory</code> which produces functions that serialize the arguments and deserialize the return value.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/ffi.clj#L426">view source</a></div></div><div class="public anchor" id="var-make-serde-wrapper"><h3>make-serde-wrapper</h3><div class="usage"><code>(make-serde-wrapper downcall arg-types ret-type)</code></div><div class="doc"><div class="markdown"><p>Constructs a wrapper function for the <code>downcall</code> which serializes the arguments and deserializes the return value.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/ffi.clj#L407">view source</a></div></div><div class="public anchor" id="var-make-varargs-factory"><h3>make-varargs-factory</h3><div class="usage"><code>(make-varargs-factory symbol required-args ret)</code></div><div class="doc"><div class="markdown"><p>Returns a function for constructing downcalls with additional types for arguments.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/ffi.clj#L206">view source</a></div></div><div class="public anchor" id="var-make-serde-varargs-wrapper"><h3>make-serde-varargs-wrapper</h3><div class="usage"><code>(make-serde-varargs-wrapper varargs-factory required-args ret-type)</code></div><div class="doc"><div class="markdown"><p>Constructs a wrapper function for the <code>varargs-factory</code> which produces functions that serialize the arguments and deserialize the return value.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/ffi.clj#L426">view source</a></div></div><div class="public anchor" id="var-make-serde-wrapper"><h3>make-serde-wrapper</h3><div class="usage"><code>(make-serde-wrapper downcall arg-types ret-type)</code></div><div class="doc"><div class="markdown"><p>Constructs a wrapper function for the <code>downcall</code> which serializes the arguments and deserializes the return value.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/ffi.clj#L407">view source</a></div></div><div class="public anchor" id="var-make-varargs-factory"><h3>make-varargs-factory</h3><div class="usage"><code>(make-varargs-factory symbol required-args ret)</code></div><div class="doc"><div class="markdown"><p>Returns a function for constructing downcalls with additional types for arguments.</p>
 <p>The <code>required-args</code> are the types of the first arguments passed to the downcall handle, and the values passed to the returned function are only the varargs types.</p>
 <p>The returned function is memoized, so that only one downcall function will be generated per combination of argument types.</p>
 <p>See <a href="coffi.ffi.html#var-make-downcall">make-downcall</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/ffi.clj#L222">view source</a></div></div><div class="public anchor" id="var-reify-libspec"><h3>reify-libspec</h3><div class="usage"><code>(reify-libspec libspec)</code></div><div class="doc"><div class="markdown"><p>Loads all the symbols specified in the <code>libspec</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/ffi.clj#L222">view source</a></div></div><div class="public anchor" id="var-reify-libspec"><h3>reify-libspec</h3><div class="usage"><code>(reify-libspec libspec)</code></div><div class="doc"><div class="markdown"><p>Loads all the symbols specified in the <code>libspec</code>.</p>
 <p>The value of each key of the passed map is transformed as by <a href="coffi.ffi.html#var-reify-symbolspec">reify-symbolspec</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/ffi.clj#L742">view source</a></div></div><div class="public anchor" id="var-reify-symbolspec"><h3>reify-symbolspec</h3><h4 class="type">multimethod</h4><div class="usage"></div><div class="doc"><div class="markdown"><p>Takes a spec for a symbol reference and returns a live value for that type.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/ffi.clj#L701">view source</a></div></div><div class="public anchor" id="var-static-variable"><h3>static-variable</h3><div class="usage"><code>(static-variable symbol-or-addr type)</code></div><div class="doc"><div class="markdown"><p>Constructs a reference to a mutable value stored in <code>symbol-or-addr</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/ffi.clj#L742">view source</a></div></div><div class="public anchor" id="var-reify-symbolspec"><h3>reify-symbolspec</h3><h4 class="type">multimethod</h4><div class="usage"></div><div class="doc"><div class="markdown"><p>Takes a spec for a symbol reference and returns a live value for that type.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/ffi.clj#L701">view source</a></div></div><div class="public anchor" id="var-static-variable"><h3>static-variable</h3><div class="usage"><code>(static-variable symbol-or-addr type)</code></div><div class="doc"><div class="markdown"><p>Constructs a reference to a mutable value stored in <code>symbol-or-addr</code>.</p>
 <p>The returned value can be dereferenced, and has metadata.</p>
 <p>See <a href="coffi.ffi.html#var-freset.21">freset!</a>, <a href="coffi.ffi.html#var-fswap.21">fswap!</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/ffi.clj#L672">view source</a></div></div><div class="public anchor" id="var-static-variable-segment"><h3>static-variable-segment</h3><div class="usage"><code>(static-variable-segment static-var)</code></div><div class="doc"><div class="markdown"><p>Gets the backing <a href="null">MemorySegment</a> from <code>static-var</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/ffi.clj#L672">view source</a></div></div><div class="public anchor" id="var-static-variable-segment"><h3>static-variable-segment</h3><div class="usage"><code>(static-variable-segment static-var)</code></div><div class="doc"><div class="markdown"><p>Gets the backing <a href="null">MemorySegment</a> from <code>static-var</code>.</p>
 <p>This is primarily useful when you need to pass the static variable’s address to a native function which takes an <a href="null">Addressable</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/ffi.clj#L664">view source</a></div></div><div class="public anchor" id="var-vacfn-factory"><h3>vacfn-factory</h3><div class="usage"><code>(vacfn-factory symbol required-args ret)</code></div><div class="doc"><div class="markdown"><p>Constructs a varargs factory to call the native function referenced by <code>symbol</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/ffi.clj#L664">view source</a></div></div><div class="public anchor" id="var-vacfn-factory"><h3>vacfn-factory</h3><div class="usage"><code>(vacfn-factory symbol required-args ret)</code></div><div class="doc"><div class="markdown"><p>Constructs a varargs factory to call the native function referenced by <code>symbol</code>.</p>
 <p>The function returned takes any number of type arguments and returns a specialized Clojure function for calling the native function with those arguments.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/ffi.clj#L453">view source</a></div></div></div></body></html>
\ No newline at end of file
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/ffi.clj#L453">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/coffi.layout.html b/docs/coffi.layout.html
index bff4af1..0783ab7 100644
--- a/docs/coffi.layout.html
+++ b/docs/coffi.layout.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>coffi.layout documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch current"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="coffi.layout.html#var-with-c-layout"><div class="inner"><span>with-c-layout</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">coffi.layout</h1><div class="doc"><div class="markdown"><p>Functions for adjusting the layout of structs.</p>
+<html><head><meta charset="UTF-8" /><title>coffi.layout documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li><li class="depth-1 "><a href="02-Memory-Management.html"><div class="inner"><span>Memory Management</span></div></a></li><li class="depth-1 "><a href="03-Builtin-Types.html"><div class="inner"><span>Built-in Types</span></div></a></li><li class="depth-1 "><a href="04-Custom-Types.html"><div class="inner"><span>Custom Types</span></div></a></li><li class="depth-1 "><a href="05-Low-Level-Wrappers.html"><div class="inner"><span>Low-Level Wrappers</span></div></a></li><li class="depth-1 "><a href="50-Data-Model.html"><div class="inner"><span>Data Model</span></div></a></li><li class="depth-1 "><a href="99-Benchmarks.html"><div class="inner"><span>Benchmarks</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch current"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="coffi.layout.html#var-with-c-layout"><div class="inner"><span>with-c-layout</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">coffi.layout</h1><div class="doc"><div class="markdown"><p>Functions for adjusting the layout of structs.</p>
 </div></div><div class="public anchor" id="var-with-c-layout"><h3>with-c-layout</h3><div class="usage"><code>(with-c-layout struct-spec)</code></div><div class="doc"><div class="markdown"><p>Forces a struct specification to C layout rules.</p>
 <p>This will add padding fields between fields to match C alignment requirements.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/layout.clj#L6">view source</a></div></div></div></body></html>
\ No newline at end of file
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/layout.clj#L6">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/coffi.mem.html b/docs/coffi.mem.html
index cc459be..0afc416 100644
--- a/docs/coffi.mem.html
+++ b/docs/coffi.mem.html
@@ -1,121 +1,121 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>coffi.mem documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2 current"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="coffi.mem.html#var-address-of"><div class="inner"><span>address-of</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-address.3F"><div class="inner"><span>address?</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-align-of"><div class="inner"><span>align-of</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-alloc"><div class="inner"><span>alloc</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-alloc-instance"><div class="inner"><span>alloc-instance</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-alloc-with"><div class="inner"><span>alloc-with</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-arena-allocator"><div class="inner"><span>arena-allocator</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-as-segment"><div class="inner"><span>as-segment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-auto-arena"><div class="inner"><span>auto-arena</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-big-endian"><div class="inner"><span>big-endian</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-byte-layout"><div class="inner"><span>byte-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-c-layout"><div class="inner"><span>c-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-char-layout"><div class="inner"><span>char-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-clone-segment"><div class="inner"><span>clone-segment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-confined-arena"><div class="inner"><span>confined-arena</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-copy-segment"><div class="inner"><span>copy-segment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-defalias"><div class="inner"><span>defalias</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-deserialize"><div class="inner"><span>deserialize</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-deserialize*"><div class="inner"><span>deserialize*</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-deserialize-from"><div class="inner"><span>deserialize-from</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-double-alignment"><div class="inner"><span>double-alignment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-double-layout"><div class="inner"><span>double-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-double-size"><div class="inner"><span>double-size</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-float-alignment"><div class="inner"><span>float-alignment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-float-layout"><div class="inner"><span>float-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-float-size"><div class="inner"><span>float-size</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-global-arena"><div class="inner"><span>global-arena</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-int-alignment"><div class="inner"><span>int-alignment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-int-layout"><div class="inner"><span>int-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-int-size"><div class="inner"><span>int-size</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-java-layout"><div class="inner"><span>java-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-java-prim-layout"><div class="inner"><span>java-prim-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-little-endian"><div class="inner"><span>little-endian</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-long-alignment"><div class="inner"><span>long-alignment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-long-layout"><div class="inner"><span>long-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-long-size"><div class="inner"><span>long-size</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-native-endian"><div class="inner"><span>native-endian</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-null"><div class="inner"><span>null</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-null.3F"><div class="inner"><span>null?</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-pointer-alignment"><div class="inner"><span>pointer-alignment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-pointer-layout"><div class="inner"><span>pointer-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-pointer-size"><div class="inner"><span>pointer-size</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-primitive-type"><div class="inner"><span>primitive-type</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-primitive-types"><div class="inner"><span>primitive-types</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-primitive.3F"><div class="inner"><span>primitive?</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-address"><div class="inner"><span>read-address</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-byte"><div class="inner"><span>read-byte</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-char"><div class="inner"><span>read-char</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-double"><div class="inner"><span>read-double</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-float"><div class="inner"><span>read-float</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-int"><div class="inner"><span>read-int</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-long"><div class="inner"><span>read-long</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-short"><div class="inner"><span>read-short</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-reinterpret"><div class="inner"><span>reinterpret</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-seq-of"><div class="inner"><span>seq-of</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-serialize"><div class="inner"><span>serialize</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-serialize*"><div class="inner"><span>serialize*</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-serialize-into"><div class="inner"><span>serialize-into</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-shared-arena"><div class="inner"><span>shared-arena</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-short-alignment"><div class="inner"><span>short-alignment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-short-layout"><div class="inner"><span>short-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-short-size"><div class="inner"><span>short-size</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-size-of"><div class="inner"><span>size-of</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-slice"><div class="inner"><span>slice</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-slice-segments"><div class="inner"><span>slice-segments</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-address"><div class="inner"><span>write-address</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-byte"><div class="inner"><span>write-byte</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-char"><div class="inner"><span>write-char</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-double"><div class="inner"><span>write-double</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-float"><div class="inner"><span>write-float</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-int"><div class="inner"><span>write-int</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-long"><div class="inner"><span>write-long</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-short"><div class="inner"><span>write-short</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">coffi.mem</h1><div class="doc"><div class="markdown"><p>Functions for managing native allocations, memory arenas, and (de)serialization.</p>
+<html><head><meta charset="UTF-8" /><title>coffi.mem documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li><li class="depth-1 "><a href="02-Memory-Management.html"><div class="inner"><span>Memory Management</span></div></a></li><li class="depth-1 "><a href="03-Builtin-Types.html"><div class="inner"><span>Built-in Types</span></div></a></li><li class="depth-1 "><a href="04-Custom-Types.html"><div class="inner"><span>Custom Types</span></div></a></li><li class="depth-1 "><a href="05-Low-Level-Wrappers.html"><div class="inner"><span>Low-Level Wrappers</span></div></a></li><li class="depth-1 "><a href="50-Data-Model.html"><div class="inner"><span>Data Model</span></div></a></li><li class="depth-1 "><a href="99-Benchmarks.html"><div class="inner"><span>Benchmarks</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2 current"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="coffi.mem.html#var-address-of"><div class="inner"><span>address-of</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-address.3F"><div class="inner"><span>address?</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-align-of"><div class="inner"><span>align-of</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-alloc"><div class="inner"><span>alloc</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-alloc-instance"><div class="inner"><span>alloc-instance</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-alloc-with"><div class="inner"><span>alloc-with</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-arena-allocator"><div class="inner"><span>arena-allocator</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-as-segment"><div class="inner"><span>as-segment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-auto-arena"><div class="inner"><span>auto-arena</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-big-endian"><div class="inner"><span>big-endian</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-byte-layout"><div class="inner"><span>byte-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-c-layout"><div class="inner"><span>c-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-char-layout"><div class="inner"><span>char-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-clone-segment"><div class="inner"><span>clone-segment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-confined-arena"><div class="inner"><span>confined-arena</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-copy-segment"><div class="inner"><span>copy-segment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-defalias"><div class="inner"><span>defalias</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-deserialize"><div class="inner"><span>deserialize</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-deserialize*"><div class="inner"><span>deserialize*</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-deserialize-from"><div class="inner"><span>deserialize-from</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-double-alignment"><div class="inner"><span>double-alignment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-double-layout"><div class="inner"><span>double-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-double-size"><div class="inner"><span>double-size</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-float-alignment"><div class="inner"><span>float-alignment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-float-layout"><div class="inner"><span>float-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-float-size"><div class="inner"><span>float-size</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-global-arena"><div class="inner"><span>global-arena</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-int-alignment"><div class="inner"><span>int-alignment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-int-layout"><div class="inner"><span>int-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-int-size"><div class="inner"><span>int-size</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-java-layout"><div class="inner"><span>java-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-java-prim-layout"><div class="inner"><span>java-prim-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-little-endian"><div class="inner"><span>little-endian</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-long-alignment"><div class="inner"><span>long-alignment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-long-layout"><div class="inner"><span>long-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-long-size"><div class="inner"><span>long-size</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-native-endian"><div class="inner"><span>native-endian</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-null"><div class="inner"><span>null</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-null.3F"><div class="inner"><span>null?</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-pointer-alignment"><div class="inner"><span>pointer-alignment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-pointer-layout"><div class="inner"><span>pointer-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-pointer-size"><div class="inner"><span>pointer-size</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-primitive-type"><div class="inner"><span>primitive-type</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-primitive-types"><div class="inner"><span>primitive-types</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-primitive.3F"><div class="inner"><span>primitive?</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-address"><div class="inner"><span>read-address</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-byte"><div class="inner"><span>read-byte</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-char"><div class="inner"><span>read-char</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-double"><div class="inner"><span>read-double</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-float"><div class="inner"><span>read-float</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-int"><div class="inner"><span>read-int</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-long"><div class="inner"><span>read-long</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-short"><div class="inner"><span>read-short</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-reinterpret"><div class="inner"><span>reinterpret</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-seq-of"><div class="inner"><span>seq-of</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-serialize"><div class="inner"><span>serialize</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-serialize*"><div class="inner"><span>serialize*</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-serialize-into"><div class="inner"><span>serialize-into</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-shared-arena"><div class="inner"><span>shared-arena</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-short-alignment"><div class="inner"><span>short-alignment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-short-layout"><div class="inner"><span>short-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-short-size"><div class="inner"><span>short-size</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-size-of"><div class="inner"><span>size-of</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-slice"><div class="inner"><span>slice</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-slice-segments"><div class="inner"><span>slice-segments</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-address"><div class="inner"><span>write-address</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-byte"><div class="inner"><span>write-byte</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-char"><div class="inner"><span>write-char</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-double"><div class="inner"><span>write-double</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-float"><div class="inner"><span>write-float</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-int"><div class="inner"><span>write-int</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-long"><div class="inner"><span>write-long</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-short"><div class="inner"><span>write-short</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">coffi.mem</h1><div class="doc"><div class="markdown"><p>Functions for managing native allocations, memory arenas, and (de)serialization.</p>
 <p>For any new type to be implemented, three multimethods must be overriden, but which three depends on the native representation of the type.</p>
 <p>If the native representation of the type is a primitive (whether or not other data beyond the primitive is associated with it, as e.g. a pointer), then <a href="coffi.mem.html#var-primitive-type">primitive-type</a> must be overriden to return which primitive type it is serialized as, then <a href="coffi.mem.html#var-serialize*">serialize*</a> and <a href="coffi.mem.html#var-deserialize*">deserialize*</a> should be overriden.</p>
 <p>If the native representation of the type is a composite type, like a union, struct, or array, then <a href="coffi.mem.html#var-c-layout">c-layout</a> must be overriden to return the native layout of the type, and <a href="coffi.mem.html#var-serialize-into">serialize-into</a> and <a href="coffi.mem.html#var-deserialize-from">deserialize-from</a> should be overriden to allow marshaling values of the type into and out of memory segments.</p>
 </div></div><div class="public anchor" id="var-address-of"><h3>address-of</h3><div class="usage"><code>(address-of addressable)</code></div><div class="doc"><div class="markdown"><p>Gets the address of a given segment as a number.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L106">view source</a></div></div><div class="public anchor" id="var-address.3F"><h3>address?</h3><div class="usage"><code>(address? addr)</code></div><div class="doc"><div class="markdown"><p>Checks if an object is a memory address.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L106">view source</a></div></div><div class="public anchor" id="var-address.3F"><h3>address?</h3><div class="usage"><code>(address? addr)</code></div><div class="doc"><div class="markdown"><p>Checks if an object is a memory address.</p>
 <p><code>nil</code> is considered an address.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L124">view source</a></div></div><div class="public anchor" id="var-align-of"><h3>align-of</h3><div class="usage"><code>(align-of type)</code></div><div class="doc"><div class="markdown"><p>The alignment in bytes of the given <code>type</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L811">view source</a></div></div><div class="public anchor" id="var-alloc"><h3>alloc</h3><div class="usage"><code>(alloc size)</code><code>(alloc size arena)</code><code>(alloc size alignment arena)</code></div><div class="doc"><div class="markdown"><p>Allocates <code>size</code> bytes.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L124">view source</a></div></div><div class="public anchor" id="var-align-of"><h3>align-of</h3><div class="usage"><code>(align-of type)</code></div><div class="doc"><div class="markdown"><p>The alignment in bytes of the given <code>type</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L811">view source</a></div></div><div class="public anchor" id="var-alloc"><h3>alloc</h3><div class="usage"><code>(alloc size)</code><code>(alloc size arena)</code><code>(alloc size alignment arena)</code></div><div class="doc"><div class="markdown"><p>Allocates <code>size</code> bytes.</p>
 <p>If an <code>arena</code> is provided, the allocation will be reclaimed when it is closed.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L91">view source</a></div></div><div class="public anchor" id="var-alloc-instance"><h3>alloc-instance</h3><div class="usage"><code>(alloc-instance type)</code><code>(alloc-instance type arena)</code></div><div class="doc"><div class="markdown"><p>Allocates a memory segment for the given <code>type</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L818">view source</a></div></div><div class="public anchor" id="var-alloc-with"><h3>alloc-with</h3><div class="usage"><code>(alloc-with allocator size)</code><code>(alloc-with allocator size alignment)</code></div><div class="doc"><div class="markdown"><p>Allocates <code>size</code> bytes using the <code>allocator</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L99">view source</a></div></div><div class="public anchor" id="var-arena-allocator"><h3>arena-allocator</h3><div class="usage"><code>(arena-allocator arena)</code></div><div class="doc"><div class="markdown"><p>Constructs a <a href="null">SegmentAllocator</a> from the given <a href="null">Arena</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L91">view source</a></div></div><div class="public anchor" id="var-alloc-instance"><h3>alloc-instance</h3><div class="usage"><code>(alloc-instance type)</code><code>(alloc-instance type arena)</code></div><div class="doc"><div class="markdown"><p>Allocates a memory segment for the given <code>type</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L818">view source</a></div></div><div class="public anchor" id="var-alloc-with"><h3>alloc-with</h3><div class="usage"><code>(alloc-with allocator size)</code><code>(alloc-with allocator size alignment)</code></div><div class="doc"><div class="markdown"><p>Allocates <code>size</code> bytes using the <code>allocator</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L99">view source</a></div></div><div class="public anchor" id="var-arena-allocator"><h3>arena-allocator</h3><div class="usage"><code>(arena-allocator arena)</code></div><div class="doc"><div class="markdown"><p>Constructs a <a href="null">SegmentAllocator</a> from the given <a href="null">Arena</a>.</p>
 <p>This is primarily used when working with unwrapped downcall functions. When a downcall function returns a non-primitive type, it must be provided with an allocator.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L80">view source</a></div></div><div class="public anchor" id="var-as-segment"><h3>as-segment</h3><div class="usage"><code>(as-segment address)</code><code>(as-segment address size)</code><code>(as-segment address size arena)</code><code>(as-segment address size arena cleanup)</code></div><div class="doc"><div class="markdown"><p>Dereferences an <code>address</code> into a memory segment associated with the <code>arena</code> (default global).</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L156">view source</a></div></div><div class="public anchor" id="var-auto-arena"><h3>auto-arena</h3><div class="usage"><code>(auto-arena)</code></div><div class="doc"><div class="markdown"><p>Constructs a new memory arena that is managed by the garbage collector.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L80">view source</a></div></div><div class="public anchor" id="var-as-segment"><h3>as-segment</h3><div class="usage"><code>(as-segment address)</code><code>(as-segment address size)</code><code>(as-segment address size arena)</code><code>(as-segment address size arena cleanup)</code></div><div class="doc"><div class="markdown"><p>Dereferences an <code>address</code> into a memory segment associated with the <code>arena</code> (default global).</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L156">view source</a></div></div><div class="public anchor" id="var-auto-arena"><h3>auto-arena</h3><div class="usage"><code>(auto-arena)</code></div><div class="doc"><div class="markdown"><p>Constructs a new memory arena that is managed by the garbage collector.</p>
 <p>The arena may be shared across threads, and all resources created with it will be cleaned up at the same time, when all references have been collected.</p>
 <p>This type of arena cannot be closed, and therefore should not be created in a <a href="null">with-open</a> clause.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L59">view source</a></div></div><div class="public anchor" id="var-big-endian"><h3>big-endian</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The big-endian <a href="null">ByteOrder</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L59">view source</a></div></div><div class="public anchor" id="var-big-endian"><h3>big-endian</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The big-endian <a href="null">ByteOrder</a>.</p>
 <p>See <a href="coffi.mem.html#var-little-endian">little-endian</a>, <a href="coffi.mem.html#var-native-endian">native-endian</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L187">view source</a></div></div><div class="public anchor" id="var-byte-layout"><h3>byte-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a byte in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L205">view source</a></div></div><div class="public anchor" id="var-c-layout"><h3>c-layout</h3><h4 class="type">multimethod</h4><div class="usage"></div><div class="doc"><div class="markdown"><p>Gets the layout object for a given <code>type</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L187">view source</a></div></div><div class="public anchor" id="var-byte-layout"><h3>byte-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a byte in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L205">view source</a></div></div><div class="public anchor" id="var-c-layout"><h3>c-layout</h3><h4 class="type">multimethod</h4><div class="usage"></div><div class="doc"><div class="markdown"><p>Gets the layout object for a given <code>type</code>.</p>
 <p>If a type is primitive it will return the appropriate primitive layout (see <a href="null">c-prim-layout</a>).</p>
 <p>Otherwise, it should return a <a href="null">GroupLayout</a> for the given type.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L729">view source</a></div></div><div class="public anchor" id="var-char-layout"><h3>char-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a c-sized char in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L221">view source</a></div></div><div class="public anchor" id="var-clone-segment"><h3>clone-segment</h3><div class="usage"><code>(clone-segment segment)</code><code>(clone-segment segment arena)</code></div><div class="doc"><div class="markdown"><p>Clones the content of <code>segment</code> into a new segment of the same size.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L174">view source</a></div></div><div class="public anchor" id="var-confined-arena"><h3>confined-arena</h3><div class="usage"><code>(confined-arena)</code></div><div class="doc"><div class="markdown"><p>Constructs a new arena for use only in this thread.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L729">view source</a></div></div><div class="public anchor" id="var-char-layout"><h3>char-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a c-sized char in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L221">view source</a></div></div><div class="public anchor" id="var-clone-segment"><h3>clone-segment</h3><div class="usage"><code>(clone-segment segment)</code><code>(clone-segment segment arena)</code></div><div class="doc"><div class="markdown"><p>Clones the content of <code>segment</code> into a new segment of the same size.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L174">view source</a></div></div><div class="public anchor" id="var-confined-arena"><h3>confined-arena</h3><div class="usage"><code>(confined-arena)</code></div><div class="doc"><div class="markdown"><p>Constructs a new arena for use only in this thread.</p>
 <p>The memory allocated within this arena is cheap to allocate, like a native stack.</p>
 <p>The memory allocated within this arena will be cleared once it is closed, so it is usually a good idea to create it in a <a href="null">with-open</a> clause.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L40">view source</a></div></div><div class="public anchor" id="var-copy-segment"><h3>copy-segment</h3><div class="usage"><code>(copy-segment dest src)</code></div><div class="doc"><div class="markdown"><p>Copies the content to <code>dest</code> from <code>src</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L40">view source</a></div></div><div class="public anchor" id="var-copy-segment"><h3>copy-segment</h3><div class="usage"><code>(copy-segment dest src)</code></div><div class="doc"><div class="markdown"><p>Copies the content to <code>dest</code> from <code>src</code>.</p>
 <p>Returns <code>dest</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L167">view source</a></div></div><div class="public anchor" id="var-defalias"><h3>defalias</h3><h4 class="type">macro</h4><div class="usage"><code>(defalias new-type aliased-type)</code></div><div class="doc"><div class="markdown"><p>Defines a type alias from <code>new-type</code> to <code>aliased-type</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L167">view source</a></div></div><div class="public anchor" id="var-defalias"><h3>defalias</h3><h4 class="type">macro</h4><div class="usage"><code>(defalias new-type aliased-type)</code></div><div class="doc"><div class="markdown"><p>Defines a type alias from <code>new-type</code> to <code>aliased-type</code>.</p>
 <p>This creates needed serialization and deserialization implementations for the aliased type.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L1319">view source</a></div></div><div class="public anchor" id="var-deserialize"><h3>deserialize</h3><div class="usage"><code>(deserialize obj type)</code></div><div class="doc"><div class="markdown"><p>Deserializes an arbitrary type.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L1319">view source</a></div></div><div class="public anchor" id="var-deserialize"><h3>deserialize</h3><div class="usage"><code>(deserialize obj type)</code></div><div class="doc"><div class="markdown"><p>Deserializes an arbitrary type.</p>
 <p>For types which have a primitive representation, this deserializes the primitive representation. For types which do not, this deserializes out of a segment.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L1092">view source</a></div></div><div class="public anchor" id="var-deserialize*"><h3>deserialize*</h3><h4 class="type">multimethod</h4><div class="usage"></div><div class="doc"><div class="markdown"><p>Deserializes a primitive object into a Clojure data structure.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L1092">view source</a></div></div><div class="public anchor" id="var-deserialize*"><h3>deserialize*</h3><h4 class="type">multimethod</h4><div class="usage"></div><div class="doc"><div class="markdown"><p>Deserializes a primitive object into a Clojure data structure.</p>
 <p>This is intended for use with types that are returned as a primitive but which need additional processing before they can be returned.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L1033">view source</a></div></div><div class="public anchor" id="var-deserialize-from"><h3>deserialize-from</h3><h4 class="type">multimethod</h4><div class="usage"></div><div class="doc"><div class="markdown"><p>Deserializes the given segment into a Clojure data structure.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L1033">view source</a></div></div><div class="public anchor" id="var-deserialize-from"><h3>deserialize-from</h3><h4 class="type">multimethod</h4><div class="usage"></div><div class="doc"><div class="markdown"><p>Deserializes the given segment into a Clojure data structure.</p>
 <p>For types that serialize to primitives, a default implementation will deserialize the primitive before calling <a href="coffi.mem.html#var-deserialize*">deserialize*</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L970">view source</a></div></div><div class="public anchor" id="var-double-alignment"><h3>double-alignment</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The alignment in bytes of a c-sized double.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L277">view source</a></div></div><div class="public anchor" id="var-double-layout"><h3>double-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a c-sized double in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L229">view source</a></div></div><div class="public anchor" id="var-double-size"><h3>double-size</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The size in bytes of a c-sized double.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L253">view source</a></div></div><div class="public anchor" id="var-float-alignment"><h3>float-alignment</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The alignment in bytes of a c-sized float.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L273">view source</a></div></div><div class="public anchor" id="var-float-layout"><h3>float-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a c-sized float in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L225">view source</a></div></div><div class="public anchor" id="var-float-size"><h3>float-size</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The size in bytes of a c-sized float.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L249">view source</a></div></div><div class="public anchor" id="var-global-arena"><h3>global-arena</h3><div class="usage"><code>(global-arena)</code></div><div class="doc"><div class="markdown"><p>Constructs the global arena, which will never reclaim its resources.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L970">view source</a></div></div><div class="public anchor" id="var-double-alignment"><h3>double-alignment</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The alignment in bytes of a c-sized double.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L277">view source</a></div></div><div class="public anchor" id="var-double-layout"><h3>double-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a c-sized double in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L229">view source</a></div></div><div class="public anchor" id="var-double-size"><h3>double-size</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The size in bytes of a c-sized double.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L253">view source</a></div></div><div class="public anchor" id="var-float-alignment"><h3>float-alignment</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The alignment in bytes of a c-sized float.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L273">view source</a></div></div><div class="public anchor" id="var-float-layout"><h3>float-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a c-sized float in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L225">view source</a></div></div><div class="public anchor" id="var-float-size"><h3>float-size</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The size in bytes of a c-sized float.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L249">view source</a></div></div><div class="public anchor" id="var-global-arena"><h3>global-arena</h3><div class="usage"><code>(global-arena)</code></div><div class="doc"><div class="markdown"><p>Constructs the global arena, which will never reclaim its resources.</p>
 <p>This arena may be shared across threads, but is intended mainly in cases where memory is allocated with <a href="coffi.mem.html#var-alloc">alloc</a> but is either never freed or whose management is relinquished to a native library, such as when returned from a callback.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L70">view source</a></div></div><div class="public anchor" id="var-int-alignment"><h3>int-alignment</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The alignment in bytes of a c-sized int.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L265">view source</a></div></div><div class="public anchor" id="var-int-layout"><h3>int-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a c-sized int in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L213">view source</a></div></div><div class="public anchor" id="var-int-size"><h3>int-size</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The size in bytes of a c-sized int.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L241">view source</a></div></div><div class="public anchor" id="var-java-layout"><h3>java-layout</h3><div class="usage"><code>(java-layout type)</code></div><div class="doc"><div class="markdown"><p>Gets the Java class to an argument of this type for a method handle.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L70">view source</a></div></div><div class="public anchor" id="var-int-alignment"><h3>int-alignment</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The alignment in bytes of a c-sized int.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L265">view source</a></div></div><div class="public anchor" id="var-int-layout"><h3>int-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a c-sized int in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L213">view source</a></div></div><div class="public anchor" id="var-int-size"><h3>int-size</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The size in bytes of a c-sized int.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L241">view source</a></div></div><div class="public anchor" id="var-java-layout"><h3>java-layout</h3><div class="usage"><code>(java-layout type)</code></div><div class="doc"><div class="markdown"><p>Gets the Java class to an argument of this type for a method handle.</p>
 <p>If a type serializes to a primitive it returns return a Java primitive type. Otherwise, it returns <a href="null">MemorySegment</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L796">view source</a></div></div><div class="public anchor" id="var-java-prim-layout"><h3>java-prim-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Map of primitive type names to the Java types for a method handle.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L784">view source</a></div></div><div class="public anchor" id="var-little-endian"><h3>little-endian</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The little-endian <a href="null">ByteOrder</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L796">view source</a></div></div><div class="public anchor" id="var-java-prim-layout"><h3>java-prim-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Map of primitive type names to the Java types for a method handle.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L784">view source</a></div></div><div class="public anchor" id="var-little-endian"><h3>little-endian</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The little-endian <a href="null">ByteOrder</a>.</p>
 <p>See <a href="coffi.mem.html#var-big-endian">big-endian</a>, <a href="coffi.mem.html#var-native-endian">native-endian</a></p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L193">view source</a></div></div><div class="public anchor" id="var-long-alignment"><h3>long-alignment</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The alignment in bytes of a c-sized long.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L269">view source</a></div></div><div class="public anchor" id="var-long-layout"><h3>long-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a c-sized long in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L217">view source</a></div></div><div class="public anchor" id="var-long-size"><h3>long-size</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The size in bytes of a c-sized long.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L245">view source</a></div></div><div class="public anchor" id="var-native-endian"><h3>native-endian</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">ByteOrder</a> for the native endianness of the current hardware.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L193">view source</a></div></div><div class="public anchor" id="var-long-alignment"><h3>long-alignment</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The alignment in bytes of a c-sized long.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L269">view source</a></div></div><div class="public anchor" id="var-long-layout"><h3>long-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a c-sized long in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L217">view source</a></div></div><div class="public anchor" id="var-long-size"><h3>long-size</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The size in bytes of a c-sized long.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L245">view source</a></div></div><div class="public anchor" id="var-native-endian"><h3>native-endian</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">ByteOrder</a> for the native endianness of the current hardware.</p>
 <p>See <a href="coffi.mem.html#var-big-endian">big-endian</a>, <a href="coffi.mem.html#var-little-endian">little-endian</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L199">view source</a></div></div><div class="public anchor" id="var-null"><h3>null</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The NULL pointer object.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L199">view source</a></div></div><div class="public anchor" id="var-null"><h3>null</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The NULL pointer object.</p>
 <p>While this object is safe to pass to functions which serialize to a pointer, it’s generally encouraged to simply pass <code>nil</code>. This value primarily exists to make it easier to write custom types with a primitive pointer representation.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L111">view source</a></div></div><div class="public anchor" id="var-null.3F"><h3>null?</h3><div class="usage"><code>(null? addr)</code></div><div class="doc"><div class="markdown"><p>Checks if a memory address is null.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L119">view source</a></div></div><div class="public anchor" id="var-pointer-alignment"><h3>pointer-alignment</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The alignment in bytes of a c-sized pointer.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L281">view source</a></div></div><div class="public anchor" id="var-pointer-layout"><h3>pointer-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a native pointer in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L233">view source</a></div></div><div class="public anchor" id="var-pointer-size"><h3>pointer-size</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The size in bytes of a c-sized pointer.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L257">view source</a></div></div><div class="public anchor" id="var-primitive-type"><h3>primitive-type</h3><h4 class="type">multimethod</h4><div class="usage"></div><div class="doc"><div class="markdown"><p>Gets the primitive type that is used to pass as an argument for the <code>type</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L111">view source</a></div></div><div class="public anchor" id="var-null.3F"><h3>null?</h3><div class="usage"><code>(null? addr)</code></div><div class="doc"><div class="markdown"><p>Checks if a memory address is null.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L119">view source</a></div></div><div class="public anchor" id="var-pointer-alignment"><h3>pointer-alignment</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The alignment in bytes of a c-sized pointer.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L281">view source</a></div></div><div class="public anchor" id="var-pointer-layout"><h3>pointer-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a native pointer in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L233">view source</a></div></div><div class="public anchor" id="var-pointer-size"><h3>pointer-size</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The size in bytes of a c-sized pointer.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L257">view source</a></div></div><div class="public anchor" id="var-primitive-type"><h3>primitive-type</h3><h4 class="type">multimethod</h4><div class="usage"></div><div class="doc"><div class="markdown"><p>Gets the primitive type that is used to pass as an argument for the <code>type</code>.</p>
 <p>This is for objects which are passed to native functions as primitive types, but which need additional logic to be performed during serialization and deserialization.</p>
 <p>Implementations of this method should take into account that type arguments may not always be evaluated before passing to this function.</p>
 <p>Returns nil for any type which does not have a primitive representation.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L676">view source</a></div></div><div class="public anchor" id="var-primitive-types"><h3>primitive-types</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>A set of all primitive types.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L666">view source</a></div></div><div class="public anchor" id="var-primitive.3F"><h3>primitive?</h3><div class="usage"><code>(primitive? type)</code></div><div class="doc"><div class="markdown"><p>A predicate to determine if a given type is primitive.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L671">view source</a></div></div><div class="public anchor" id="var-read-address"><h3>read-address</h3><div class="usage"><code>(read-address segment)</code><code>(read-address segment offset)</code></div><div class="doc"><div class="markdown"><p>Reads an address from the <code>segment</code>, at an optional <code>offset</code>, wrapped in a <a href="null">MemorySegment</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L442">view source</a></div></div><div class="public anchor" id="var-read-byte"><h3>read-byte</h3><div class="usage"><code>(read-byte segment)</code><code>(read-byte segment offset)</code></div><div class="doc"><div class="markdown"><p>Reads a <a href="null">byte</a> from the <code>segment</code>, at an optional <code>offset</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L285">view source</a></div></div><div class="public anchor" id="var-read-char"><h3>read-char</h3><div class="usage"><code>(read-char segment)</code><code>(read-char segment offset)</code></div><div class="doc"><div class="markdown"><p>Reads a <a href="null">char</a> from the <code>segment</code>, at an optional <code>offset</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L376">view source</a></div></div><div class="public anchor" id="var-read-double"><h3>read-double</h3><div class="usage"><code>(read-double segment)</code><code>(read-double segment offset)</code><code>(read-double segment offset byte-order)</code></div><div class="doc"><div class="markdown"><p>Reads a <a href="null">double</a> from the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L676">view source</a></div></div><div class="public anchor" id="var-primitive-types"><h3>primitive-types</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>A set of all primitive types.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L666">view source</a></div></div><div class="public anchor" id="var-primitive.3F"><h3>primitive?</h3><div class="usage"><code>(primitive? type)</code></div><div class="doc"><div class="markdown"><p>A predicate to determine if a given type is primitive.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L671">view source</a></div></div><div class="public anchor" id="var-read-address"><h3>read-address</h3><div class="usage"><code>(read-address segment)</code><code>(read-address segment offset)</code></div><div class="doc"><div class="markdown"><p>Reads an address from the <code>segment</code>, at an optional <code>offset</code>, wrapped in a <a href="null">MemorySegment</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L442">view source</a></div></div><div class="public anchor" id="var-read-byte"><h3>read-byte</h3><div class="usage"><code>(read-byte segment)</code><code>(read-byte segment offset)</code></div><div class="doc"><div class="markdown"><p>Reads a <a href="null">byte</a> from the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L285">view source</a></div></div><div class="public anchor" id="var-read-char"><h3>read-char</h3><div class="usage"><code>(read-char segment)</code><code>(read-char segment offset)</code></div><div class="doc"><div class="markdown"><p>Reads a <a href="null">char</a> from the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L376">view source</a></div></div><div class="public anchor" id="var-read-double"><h3>read-double</h3><div class="usage"><code>(read-double segment)</code><code>(read-double segment offset)</code><code>(read-double segment offset byte-order)</code></div><div class="doc"><div class="markdown"><p>Reads a <a href="null">double</a> from the <code>segment</code>, at an optional <code>offset</code>.</p>
 <p>If <code>byte-order</code> is not provided, it defaults to <a href="coffi.mem.html#var-native-endian">native-endian</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L417">view source</a></div></div><div class="public anchor" id="var-read-float"><h3>read-float</h3><div class="usage"><code>(read-float segment)</code><code>(read-float segment offset)</code><code>(read-float segment offset byte-order)</code></div><div class="doc"><div class="markdown"><p>Reads a <a href="null">float</a> from the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L417">view source</a></div></div><div class="public anchor" id="var-read-float"><h3>read-float</h3><div class="usage"><code>(read-float segment)</code><code>(read-float segment offset)</code><code>(read-float segment offset byte-order)</code></div><div class="doc"><div class="markdown"><p>Reads a <a href="null">float</a> from the <code>segment</code>, at an optional <code>offset</code>.</p>
 <p>If <code>byte-order</code> is not provided, it defaults to <a href="coffi.mem.html#var-native-endian">native-endian</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L392">view source</a></div></div><div class="public anchor" id="var-read-int"><h3>read-int</h3><div class="usage"><code>(read-int segment)</code><code>(read-int segment offset)</code><code>(read-int segment offset byte-order)</code></div><div class="doc"><div class="markdown"><p>Reads a <a href="null">int</a> from the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L392">view source</a></div></div><div class="public anchor" id="var-read-int"><h3>read-int</h3><div class="usage"><code>(read-int segment)</code><code>(read-int segment offset)</code><code>(read-int segment offset byte-order)</code></div><div class="doc"><div class="markdown"><p>Reads a <a href="null">int</a> from the <code>segment</code>, at an optional <code>offset</code>.</p>
 <p>If <code>byte-order</code> is not provided, it defaults to <a href="coffi.mem.html#var-native-endian">native-endian</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L326">view source</a></div></div><div class="public anchor" id="var-read-long"><h3>read-long</h3><div class="usage"><code>(read-long segment)</code><code>(read-long segment offset)</code><code>(read-long segment offset byte-order)</code></div><div class="doc"><div class="markdown"><p>Reads a <a href="null">long</a> from the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L326">view source</a></div></div><div class="public anchor" id="var-read-long"><h3>read-long</h3><div class="usage"><code>(read-long segment)</code><code>(read-long segment offset)</code><code>(read-long segment offset byte-order)</code></div><div class="doc"><div class="markdown"><p>Reads a <a href="null">long</a> from the <code>segment</code>, at an optional <code>offset</code>.</p>
 <p>If <code>byte-order</code> is not provided, it defaults to <a href="coffi.mem.html#var-native-endian">native-endian</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L351">view source</a></div></div><div class="public anchor" id="var-read-short"><h3>read-short</h3><div class="usage"><code>(read-short segment)</code><code>(read-short segment offset)</code><code>(read-short segment offset byte-order)</code></div><div class="doc"><div class="markdown"><p>Reads a <a href="null">short</a> from the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L351">view source</a></div></div><div class="public anchor" id="var-read-short"><h3>read-short</h3><div class="usage"><code>(read-short segment)</code><code>(read-short segment offset)</code><code>(read-short segment offset byte-order)</code></div><div class="doc"><div class="markdown"><p>Reads a <a href="null">short</a> from the <code>segment</code>, at an optional <code>offset</code>.</p>
 <p>If <code>byte-order</code> is not provided, it defaults to <a href="coffi.mem.html#var-native-endian">native-endian</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L301">view source</a></div></div><div class="public anchor" id="var-reinterpret"><h3>reinterpret</h3><div class="usage"><code>(reinterpret segment size)</code><code>(reinterpret segment size arena)</code><code>(reinterpret segment size arena cleanup)</code></div><div class="doc"><div class="markdown"><p>Reinterprets the <code>segment</code> as having the passed <code>size</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L301">view source</a></div></div><div class="public anchor" id="var-reinterpret"><h3>reinterpret</h3><div class="usage"><code>(reinterpret segment size)</code><code>(reinterpret segment size arena)</code><code>(reinterpret segment size arena cleanup)</code></div><div class="doc"><div class="markdown"><p>Reinterprets the <code>segment</code> as having the passed <code>size</code>.</p>
 <p>If <code>arena</code> is passed, the scope of the <code>segment</code> is associated with the arena, as well as its access constraints. If <code>cleanup</code> is passed, it will be a 1-argument function of a fresh memory segment backed by the same memory as the returned segment which should perform any required cleanup operations. It will be called when the <code>arena</code> is closed.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L138">view source</a></div></div><div class="public anchor" id="var-seq-of"><h3>seq-of</h3><div class="usage"><code>(seq-of type segment)</code></div><div class="doc"><div class="markdown"><p>Constructs a lazy sequence of <code>type</code> elements deserialized from <code>segment</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L1104">view source</a></div></div><div class="public anchor" id="var-serialize"><h3>serialize</h3><div class="usage"><code>(serialize obj type)</code><code>(serialize obj type arena)</code></div><div class="doc"><div class="markdown"><p>Serializes an arbitrary type.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L138">view source</a></div></div><div class="public anchor" id="var-seq-of"><h3>seq-of</h3><div class="usage"><code>(seq-of type segment)</code></div><div class="doc"><div class="markdown"><p>Constructs a lazy sequence of <code>type</code> elements deserialized from <code>segment</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L1104">view source</a></div></div><div class="public anchor" id="var-serialize"><h3>serialize</h3><div class="usage"><code>(serialize obj type)</code><code>(serialize obj type arena)</code></div><div class="doc"><div class="markdown"><p>Serializes an arbitrary type.</p>
 <p>For types which have a primitive representation, this serializes into that representation. For types which do not, it allocates a new segment and serializes into that.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L954">view source</a></div></div><div class="public anchor" id="var-serialize*"><h3>serialize*</h3><h4 class="type">multimethod</h4><div class="usage"></div><div class="doc"><div class="markdown"><p>Constructs a serialized version of the <code>obj</code> and returns it.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L954">view source</a></div></div><div class="public anchor" id="var-serialize*"><h3>serialize*</h3><h4 class="type">multimethod</h4><div class="usage"></div><div class="doc"><div class="markdown"><p>Constructs a serialized version of the <code>obj</code> and returns it.</p>
 <p>Any new allocations made during the serialization should be tied to the given <code>arena</code>, except in extenuating circumstances.</p>
 <p>This method should only be implemented for types that serialize to primitives.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L825">view source</a></div></div><div class="public anchor" id="var-serialize-into"><h3>serialize-into</h3><h4 class="type">multimethod</h4><div class="usage"></div><div class="doc"><div class="markdown"><p>Writes a serialized version of the <code>obj</code> to the given <code>segment</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L825">view source</a></div></div><div class="public anchor" id="var-serialize-into"><h3>serialize-into</h3><h4 class="type">multimethod</h4><div class="usage"></div><div class="doc"><div class="markdown"><p>Writes a serialized version of the <code>obj</code> to the given <code>segment</code>.</p>
 <p>Any new allocations made during the serialization should be tied to the given <code>arena</code>, except in extenuating circumstances.</p>
 <p>This method should be implemented for any type which does not override <a href="coffi.mem.html#var-c-layout">c-layout</a>.</p>
 <p>For any other type, this will serialize it as <a href="coffi.mem.html#var-serialize*">serialize*</a> before writing the result value into the <code>segment</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L885">view source</a></div></div><div class="public anchor" id="var-shared-arena"><h3>shared-arena</h3><div class="usage"><code>(shared-arena)</code></div><div class="doc"><div class="markdown"><p>Constructs a new shared memory arena.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L885">view source</a></div></div><div class="public anchor" id="var-shared-arena"><h3>shared-arena</h3><div class="usage"><code>(shared-arena)</code></div><div class="doc"><div class="markdown"><p>Constructs a new shared memory arena.</p>
 <p>This arena can be shared across threads and memory allocated in it will only be cleaned up once any thread accessing the arena closes it.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L51">view source</a></div></div><div class="public anchor" id="var-short-alignment"><h3>short-alignment</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The alignment in bytes of a c-sized short.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L261">view source</a></div></div><div class="public anchor" id="var-short-layout"><h3>short-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a c-sized short in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L209">view source</a></div></div><div class="public anchor" id="var-short-size"><h3>short-size</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The size in bytes of a c-sized short.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L237">view source</a></div></div><div class="public anchor" id="var-size-of"><h3>size-of</h3><div class="usage"><code>(size-of type)</code></div><div class="doc"><div class="markdown"><p>The size in bytes of the given <code>type</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L804">view source</a></div></div><div class="public anchor" id="var-slice"><h3>slice</h3><div class="usage"><code>(slice segment offset)</code><code>(slice segment offset size)</code></div><div class="doc"><div class="markdown"><p>Get a slice over the <code>segment</code> with the given <code>offset</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L131">view source</a></div></div><div class="public anchor" id="var-slice-segments"><h3>slice-segments</h3><div class="usage"><code>(slice-segments segment size)</code></div><div class="doc"><div class="markdown"><p>Constructs a lazy seq of <code>size</code>-length memory segments, sliced from <code>segment</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L180">view source</a></div></div><div class="public anchor" id="var-write-address"><h3>write-address</h3><div class="usage"><code>(write-address segment value)</code><code>(write-address segment offset value)</code></div><div class="doc"><div class="markdown"><p>Writes the address of the <a href="null">MemorySegment</a> <code>value</code> to the <code>segment</code>, at an optional <code>offset</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L640">view source</a></div></div><div class="public anchor" id="var-write-byte"><h3>write-byte</h3><div class="usage"><code>(write-byte segment value)</code><code>(write-byte segment offset value)</code></div><div class="doc"><div class="markdown"><p>Writes a <a href="null">byte</a> to the <code>segment</code>, at an optional <code>offset</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L458">view source</a></div></div><div class="public anchor" id="var-write-char"><h3>write-char</h3><div class="usage"><code>(write-char segment value)</code><code>(write-char segment offset value)</code></div><div class="doc"><div class="markdown"><p>Writes a <a href="null">char</a> to the <code>segment</code>, at an optional <code>offset</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L560">view source</a></div></div><div class="public anchor" id="var-write-double"><h3>write-double</h3><div class="usage"><code>(write-double segment value)</code><code>(write-double segment offset value)</code><code>(write-double segment offset byte-order value)</code></div><div class="doc"><div class="markdown"><p>Writes a <a href="null">double</a> to the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L51">view source</a></div></div><div class="public anchor" id="var-short-alignment"><h3>short-alignment</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The alignment in bytes of a c-sized short.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L261">view source</a></div></div><div class="public anchor" id="var-short-layout"><h3>short-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a c-sized short in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L209">view source</a></div></div><div class="public anchor" id="var-short-size"><h3>short-size</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The size in bytes of a c-sized short.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L237">view source</a></div></div><div class="public anchor" id="var-size-of"><h3>size-of</h3><div class="usage"><code>(size-of type)</code></div><div class="doc"><div class="markdown"><p>The size in bytes of the given <code>type</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L804">view source</a></div></div><div class="public anchor" id="var-slice"><h3>slice</h3><div class="usage"><code>(slice segment offset)</code><code>(slice segment offset size)</code></div><div class="doc"><div class="markdown"><p>Get a slice over the <code>segment</code> with the given <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L131">view source</a></div></div><div class="public anchor" id="var-slice-segments"><h3>slice-segments</h3><div class="usage"><code>(slice-segments segment size)</code></div><div class="doc"><div class="markdown"><p>Constructs a lazy seq of <code>size</code>-length memory segments, sliced from <code>segment</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L180">view source</a></div></div><div class="public anchor" id="var-write-address"><h3>write-address</h3><div class="usage"><code>(write-address segment value)</code><code>(write-address segment offset value)</code></div><div class="doc"><div class="markdown"><p>Writes the address of the <a href="null">MemorySegment</a> <code>value</code> to the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L640">view source</a></div></div><div class="public anchor" id="var-write-byte"><h3>write-byte</h3><div class="usage"><code>(write-byte segment value)</code><code>(write-byte segment offset value)</code></div><div class="doc"><div class="markdown"><p>Writes a <a href="null">byte</a> to the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L458">view source</a></div></div><div class="public anchor" id="var-write-char"><h3>write-char</h3><div class="usage"><code>(write-char segment value)</code><code>(write-char segment offset value)</code></div><div class="doc"><div class="markdown"><p>Writes a <a href="null">char</a> to the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L560">view source</a></div></div><div class="public anchor" id="var-write-double"><h3>write-double</h3><div class="usage"><code>(write-double segment value)</code><code>(write-double segment offset value)</code><code>(write-double segment offset byte-order value)</code></div><div class="doc"><div class="markdown"><p>Writes a <a href="null">double</a> to the <code>segment</code>, at an optional <code>offset</code>.</p>
 <p>If <code>byte-order</code> is not provided, it defaults to <a href="coffi.mem.html#var-native-endian">native-endian</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L612">view source</a></div></div><div class="public anchor" id="var-write-float"><h3>write-float</h3><div class="usage"><code>(write-float segment value)</code><code>(write-float segment offset value)</code><code>(write-float segment offset byte-order value)</code></div><div class="doc"><div class="markdown"><p>Writes a <a href="null">float</a> to the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L612">view source</a></div></div><div class="public anchor" id="var-write-float"><h3>write-float</h3><div class="usage"><code>(write-float segment value)</code><code>(write-float segment offset value)</code><code>(write-float segment offset byte-order value)</code></div><div class="doc"><div class="markdown"><p>Writes a <a href="null">float</a> to the <code>segment</code>, at an optional <code>offset</code>.</p>
 <p>If <code>byte-order</code> is not provided, it defaults to <a href="coffi.mem.html#var-native-endian">native-endian</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L584">view source</a></div></div><div class="public anchor" id="var-write-int"><h3>write-int</h3><div class="usage"><code>(write-int segment value)</code><code>(write-int segment offset value)</code><code>(write-int segment offset byte-order value)</code></div><div class="doc"><div class="markdown"><p>Writes a <a href="null">int</a> to the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L584">view source</a></div></div><div class="public anchor" id="var-write-int"><h3>write-int</h3><div class="usage"><code>(write-int segment value)</code><code>(write-int segment offset value)</code><code>(write-int segment offset byte-order value)</code></div><div class="doc"><div class="markdown"><p>Writes a <a href="null">int</a> to the <code>segment</code>, at an optional <code>offset</code>.</p>
 <p>If <code>byte-order</code> is not provided, it defaults to <a href="coffi.mem.html#var-native-endian">native-endian</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L504">view source</a></div></div><div class="public anchor" id="var-write-long"><h3>write-long</h3><div class="usage"><code>(write-long segment value)</code><code>(write-long segment offset value)</code><code>(write-long segment offset byte-order value)</code></div><div class="doc"><div class="markdown"><p>Writes a <a href="null">long</a> to the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L504">view source</a></div></div><div class="public anchor" id="var-write-long"><h3>write-long</h3><div class="usage"><code>(write-long segment value)</code><code>(write-long segment offset value)</code><code>(write-long segment offset byte-order value)</code></div><div class="doc"><div class="markdown"><p>Writes a <a href="null">long</a> to the <code>segment</code>, at an optional <code>offset</code>.</p>
 <p>If <code>byte-order</code> is not provided, it defaults to <a href="coffi.mem.html#var-native-endian">native-endian</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L532">view source</a></div></div><div class="public anchor" id="var-write-short"><h3>write-short</h3><div class="usage"><code>(write-short segment value)</code><code>(write-short segment offset value)</code><code>(write-short segment offset byte-order value)</code></div><div class="doc"><div class="markdown"><p>Writes a <a href="null">short</a> to the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L532">view source</a></div></div><div class="public anchor" id="var-write-short"><h3>write-short</h3><div class="usage"><code>(write-short segment value)</code><code>(write-short segment offset value)</code><code>(write-short segment offset byte-order value)</code></div><div class="doc"><div class="markdown"><p>Writes a <a href="null">short</a> to the <code>segment</code>, at an optional <code>offset</code>.</p>
 <p>If <code>byte-order</code> is not provided, it defaults to <a href="coffi.mem.html#var-native-endian">native-endian</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/be58ac5d8037811e7d5bbb55045042a2b5a32c18/src/clj/coffi/mem.clj#L476">view source</a></div></div></div></body></html>
\ No newline at end of file
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L476">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/index.html b/docs/index.html
index 0e9517c..0009880 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>coffi v1.0.486</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></h1><div class="doc"><p>A Foreign Function Interface in Clojure for JDK 22+.</p></div><h2>Topics</h2><ul class="topics"><li><a href="01-Getting-Started.html">Getting Started</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="coffi.ffi.html">coffi.ffi</a></h3><div class="doc"><div class="markdown"><p>Functions for creating handles to native functions and loading native libraries.</p>
+<html><head><meta charset="UTF-8" /><title>coffi v1.0.486</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li><li class="depth-1 "><a href="02-Memory-Management.html"><div class="inner"><span>Memory Management</span></div></a></li><li class="depth-1 "><a href="03-Builtin-Types.html"><div class="inner"><span>Built-in Types</span></div></a></li><li class="depth-1 "><a href="04-Custom-Types.html"><div class="inner"><span>Custom Types</span></div></a></li><li class="depth-1 "><a href="05-Low-Level-Wrappers.html"><div class="inner"><span>Low-Level Wrappers</span></div></a></li><li class="depth-1 "><a href="50-Data-Model.html"><div class="inner"><span>Data Model</span></div></a></li><li class="depth-1 "><a href="99-Benchmarks.html"><div class="inner"><span>Benchmarks</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></h1><div class="doc"><p>A Foreign Function Interface in Clojure for JDK 22+.</p></div><h2>Topics</h2><ul class="topics"><li><a href="01-Getting-Started.html">Getting Started</a></li><li><a href="02-Memory-Management.html">Memory Management</a></li><li><a href="03-Builtin-Types.html">Built-in Types</a></li><li><a href="04-Custom-Types.html">Custom Types</a></li><li><a href="05-Low-Level-Wrappers.html">Low-Level Wrappers</a></li><li><a href="50-Data-Model.html">Data Model</a></li><li><a href="99-Benchmarks.html">Benchmarks</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="coffi.ffi.html">coffi.ffi</a></h3><div class="doc"><div class="markdown"><p>Functions for creating handles to native functions and loading native libraries.</p>
 </div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="coffi.ffi.html#var-cfn">cfn</a> </li><li> <a href="coffi.ffi.html#var-const">const</a> </li><li> <a href="coffi.ffi.html#var-defcfn">defcfn</a> </li><li> <a href="coffi.ffi.html#var-defconst">defconst</a> </li><li> <a href="coffi.ffi.html#var-defvar">defvar</a> </li><li> <a href="coffi.ffi.html#var-ensure-symbol">ensure-symbol</a> </li><li> <a href="coffi.ffi.html#var-find-symbol">find-symbol</a> </li><li> <a href="coffi.ffi.html#var-freset.21">freset!</a> </li><li> <a href="coffi.ffi.html#var-fswap.21">fswap!</a> </li><li> <a href="coffi.ffi.html#var-load-library">load-library</a> </li><li> <a href="coffi.ffi.html#var-load-system-library">load-system-library</a> </li><li> <a href="coffi.ffi.html#var-make-downcall">make-downcall</a> </li><li> <a href="coffi.ffi.html#var-make-serde-varargs-wrapper">make-serde-varargs-wrapper</a> </li><li> <a href="coffi.ffi.html#var-make-serde-wrapper">make-serde-wrapper</a> </li><li> <a href="coffi.ffi.html#var-make-varargs-factory">make-varargs-factory</a> </li><li> <a href="coffi.ffi.html#var-reify-libspec">reify-libspec</a> </li><li> <a href="coffi.ffi.html#var-reify-symbolspec">reify-symbolspec</a> </li><li> <a href="coffi.ffi.html#var-static-variable">static-variable</a> </li><li> <a href="coffi.ffi.html#var-static-variable-segment">static-variable-segment</a> </li><li> <a href="coffi.ffi.html#var-vacfn-factory">vacfn-factory</a> </li></ul></div></div><div class="namespace"><h3><a href="coffi.layout.html">coffi.layout</a></h3><div class="doc"><div class="markdown"><p>Functions for adjusting the layout of structs.</p>
 </div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="coffi.layout.html#var-with-c-layout">with-c-layout</a> </li></ul></div></div><div class="namespace"><h3><a href="coffi.mem.html">coffi.mem</a></h3><div class="doc"><div class="markdown"><p>Functions for managing native allocations, memory arenas, and (de)serialization.</p>
 </div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="coffi.mem.html#var-address-of">address-of</a> </li><li> <a href="coffi.mem.html#var-address.3F">address?</a> </li><li> <a href="coffi.mem.html#var-align-of">align-of</a> </li><li> <a href="coffi.mem.html#var-alloc">alloc</a> </li><li> <a href="coffi.mem.html#var-alloc-instance">alloc-instance</a> </li><li> <a href="coffi.mem.html#var-alloc-with">alloc-with</a> </li><li> <a href="coffi.mem.html#var-arena-allocator">arena-allocator</a> </li><li> <a href="coffi.mem.html#var-as-segment">as-segment</a> </li><li> <a href="coffi.mem.html#var-auto-arena">auto-arena</a> </li><li> <a href="coffi.mem.html#var-big-endian">big-endian</a> </li><li> <a href="coffi.mem.html#var-byte-layout">byte-layout</a> </li><li> <a href="coffi.mem.html#var-c-layout">c-layout</a> </li><li> <a href="coffi.mem.html#var-char-layout">char-layout</a> </li><li> <a href="coffi.mem.html#var-clone-segment">clone-segment</a> </li><li> <a href="coffi.mem.html#var-confined-arena">confined-arena</a> </li><li> <a href="coffi.mem.html#var-copy-segment">copy-segment</a> </li><li> <a href="coffi.mem.html#var-defalias">defalias</a> </li><li> <a href="coffi.mem.html#var-deserialize">deserialize</a> </li><li> <a href="coffi.mem.html#var-deserialize*">deserialize*</a> </li><li> <a href="coffi.mem.html#var-deserialize-from">deserialize-from</a> </li><li> <a href="coffi.mem.html#var-double-alignment">double-alignment</a> </li><li> <a href="coffi.mem.html#var-double-layout">double-layout</a> </li><li> <a href="coffi.mem.html#var-double-size">double-size</a> </li><li> <a href="coffi.mem.html#var-float-alignment">float-alignment</a> </li><li> <a href="coffi.mem.html#var-float-layout">float-layout</a> </li><li> <a href="coffi.mem.html#var-float-size">float-size</a> </li><li> <a href="coffi.mem.html#var-global-arena">global-arena</a> </li><li> <a href="coffi.mem.html#var-int-alignment">int-alignment</a> </li><li> <a href="coffi.mem.html#var-int-layout">int-layout</a> </li><li> <a href="coffi.mem.html#var-int-size">int-size</a> </li><li> <a href="coffi.mem.html#var-java-layout">java-layout</a> </li><li> <a href="coffi.mem.html#var-java-prim-layout">java-prim-layout</a> </li><li> <a href="coffi.mem.html#var-little-endian">little-endian</a> </li><li> <a href="coffi.mem.html#var-long-alignment">long-alignment</a> </li><li> <a href="coffi.mem.html#var-long-layout">long-layout</a> </li><li> <a href="coffi.mem.html#var-long-size">long-size</a> </li><li> <a href="coffi.mem.html#var-native-endian">native-endian</a> </li><li> <a href="coffi.mem.html#var-null">null</a> </li><li> <a href="coffi.mem.html#var-null.3F">null?</a> </li><li> <a href="coffi.mem.html#var-pointer-alignment">pointer-alignment</a> </li><li> <a href="coffi.mem.html#var-pointer-layout">pointer-layout</a> </li><li> <a href="coffi.mem.html#var-pointer-size">pointer-size</a> </li><li> <a href="coffi.mem.html#var-primitive-type">primitive-type</a> </li><li> <a href="coffi.mem.html#var-primitive-types">primitive-types</a> </li><li> <a href="coffi.mem.html#var-primitive.3F">primitive?</a> </li><li> <a href="coffi.mem.html#var-read-address">read-address</a> </li><li> <a href="coffi.mem.html#var-read-byte">read-byte</a> </li><li> <a href="coffi.mem.html#var-read-char">read-char</a> </li><li> <a href="coffi.mem.html#var-read-double">read-double</a> </li><li> <a href="coffi.mem.html#var-read-float">read-float</a> </li><li> <a href="coffi.mem.html#var-read-int">read-int</a> </li><li> <a href="coffi.mem.html#var-read-long">read-long</a> </li><li> <a href="coffi.mem.html#var-read-short">read-short</a> </li><li> <a href="coffi.mem.html#var-reinterpret">reinterpret</a> </li><li> <a href="coffi.mem.html#var-seq-of">seq-of</a> </li><li> <a href="coffi.mem.html#var-serialize">serialize</a> </li><li> <a href="coffi.mem.html#var-serialize*">serialize*</a> </li><li> <a href="coffi.mem.html#var-serialize-into">serialize-into</a> </li><li> <a href="coffi.mem.html#var-shared-arena">shared-arena</a> </li><li> <a href="coffi.mem.html#var-short-alignment">short-alignment</a> </li><li> <a href="coffi.mem.html#var-short-layout">short-layout</a> </li><li> <a href="coffi.mem.html#var-short-size">short-size</a> </li><li> <a href="coffi.mem.html#var-size-of">size-of</a> </li><li> <a href="coffi.mem.html#var-slice">slice</a> </li><li> <a href="coffi.mem.html#var-slice-segments">slice-segments</a> </li><li> <a href="coffi.mem.html#var-write-address">write-address</a> </li><li> <a href="coffi.mem.html#var-write-byte">write-byte</a> </li><li> <a href="coffi.mem.html#var-write-char">write-char</a> </li><li> <a href="coffi.mem.html#var-write-double">write-double</a> </li><li> <a href="coffi.mem.html#var-write-float">write-float</a> </li><li> <a href="coffi.mem.html#var-write-int">write-int</a> </li><li> <a href="coffi.mem.html#var-write-long">write-long</a> </li><li> <a href="coffi.mem.html#var-write-short">write-short</a> </li></ul></div></div></div></body></html>
\ No newline at end of file

From ef9b205750600b471f2467dd72519b962329932a Mon Sep 17 00:00:00 2001
From: Joshua Suskalo <joshua@suskalo.org>
Date: Fri, 4 Oct 2024 16:35:05 -0400
Subject: [PATCH 6/6] Fix a broken list and make wip stuff explicit

---
 docs/01-Getting-Started.html        |  14 ++-
 docs/02-Memory-Management.html      |   2 +-
 docs/03-Builtin-Types.html          |   2 +-
 docs/04-Custom-Types.html           |   2 +-
 docs/05-Low-Level-Wrappers.html     |   2 +-
 docs/50-Data-Model.html             |   2 +-
 docs/99-Benchmarks.html             |   2 +-
 docs/articles/01-Getting-Started.md |   1 +
 docs/articles/03-Builtin-Types.md   |   2 +-
 docs/articles/99-Benchmarks.md      |   2 +-
 docs/coffi.ffi.html                 |  42 ++++----
 docs/coffi.layout.html              |   4 +-
 docs/coffi.mem.html                 | 148 ++++++++++++++--------------
 docs/index.html                     |   2 +-
 14 files changed, 119 insertions(+), 108 deletions(-)

diff --git a/docs/01-Getting-Started.html b/docs/01-Getting-Started.html
index 3d4bb2b..b3ecc4a 100644
--- a/docs/01-Getting-Started.html
+++ b/docs/01-Getting-Started.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Getting Started</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li><li class="depth-1 "><a href="02-Memory-Management.html"><div class="inner"><span>Memory Management</span></div></a></li><li class="depth-1 "><a href="03-Builtin-Types.html"><div class="inner"><span>Built-in Types</span></div></a></li><li class="depth-1 "><a href="04-Custom-Types.html"><div class="inner"><span>Custom Types</span></div></a></li><li class="depth-1 "><a href="05-Low-Level-Wrappers.html"><div class="inner"><span>Low-Level Wrappers</span></div></a></li><li class="depth-1 "><a href="50-Data-Model.html"><div class="inner"><span>Data Model</span></div></a></li><li class="depth-1 "><a href="99-Benchmarks.html"><div class="inner"><span>Benchmarks</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#getting-started" id="getting-started"></a>Getting Started</h1>
+<html><head><meta charset="UTF-8" /><title>Getting Started</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li><li class="depth-1 "><a href="02-Memory-Management.html"><div class="inner"><span>Memory Management</span></div></a></li><li class="depth-1 "><a href="03-Builtin-Types.html"><div class="inner"><span>Built-in Types **WIP**</span></div></a></li><li class="depth-1 "><a href="04-Custom-Types.html"><div class="inner"><span>Custom Types</span></div></a></li><li class="depth-1 "><a href="05-Low-Level-Wrappers.html"><div class="inner"><span>Low-Level Wrappers</span></div></a></li><li class="depth-1 "><a href="50-Data-Model.html"><div class="inner"><span>Data Model</span></div></a></li><li class="depth-1 "><a href="99-Benchmarks.html"><div class="inner"><span>Benchmarks **OUTDATED**</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#getting-started" id="getting-started"></a>Getting Started</h1>
 <h2><a href="#installation" id="installation"></a>Installation</h2>
 <p>This library is available on Clojars. Add one of the following entries to the <code>:deps</code> key of your <code>deps.edn</code>:</p>
 <pre><code class="language-clojure">org.suskalo/coffi {:mvn/version "x.y.z"}
@@ -49,7 +49,17 @@ io.github.IGJoshua/coffi {:git/tag "x.y.z" :git/sha "abcdef0"}
 <p>This will load libz from the lib subdirectory of the current working directory. As you can see this requires the entire filename, including platform-specific file extensions.</p>
 <p>If a library is attempted to be loaded but doesn’t exist or otherwise can’t be loaded, an exception is thrown. This can be convenient as any namespace with a <code>load-library</code> call at the top level cannot be required without the library being able to be loaded.</p>
 <h3><a href="#primitive-types" id="primitive-types"></a>Primitive Types</h3>
-<p>Coffi defines a basic set of primitive types: - byte - short - int - long - char - float - double - pointer</p>
+<p>Coffi defines a basic set of primitive types:</p>
+<ul>
+<li>byte</li>
+<li>short</li>
+<li>int</li>
+<li>long</li>
+<li>char</li>
+<li>float</li>
+<li>double</li>
+<li>pointer</li>
+</ul>
 <p>Each of these types maps to their C counterpart. Values of any of these primitive types except for <code>pointer</code> will be cast with their corresponding Clojure function when they are passed as arguments to native functions. Additionally, the <code>c-string</code> type is defined, although it is not primitive.</p>
 <h3><a href="#composite-types" id="composite-types"></a>Composite Types</h3>
 <p>In addition, some composite types are also defined in coffi, including struct and union types (unions will be discussed with serialization and deserialization). For an example C struct and function:</p>
diff --git a/docs/02-Memory-Management.html b/docs/02-Memory-Management.html
index a0489fa..1ed7324 100644
--- a/docs/02-Memory-Management.html
+++ b/docs/02-Memory-Management.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Memory Management</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li><li class="depth-1  current"><a href="02-Memory-Management.html"><div class="inner"><span>Memory Management</span></div></a></li><li class="depth-1 "><a href="03-Builtin-Types.html"><div class="inner"><span>Built-in Types</span></div></a></li><li class="depth-1 "><a href="04-Custom-Types.html"><div class="inner"><span>Custom Types</span></div></a></li><li class="depth-1 "><a href="05-Low-Level-Wrappers.html"><div class="inner"><span>Low-Level Wrappers</span></div></a></li><li class="depth-1 "><a href="50-Data-Model.html"><div class="inner"><span>Data Model</span></div></a></li><li class="depth-1 "><a href="99-Benchmarks.html"><div class="inner"><span>Benchmarks</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#memory-management" id="memory-management"></a>Memory Management</h1>
+<html><head><meta charset="UTF-8" /><title>Memory Management</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li><li class="depth-1  current"><a href="02-Memory-Management.html"><div class="inner"><span>Memory Management</span></div></a></li><li class="depth-1 "><a href="03-Builtin-Types.html"><div class="inner"><span>Built-in Types **WIP**</span></div></a></li><li class="depth-1 "><a href="04-Custom-Types.html"><div class="inner"><span>Custom Types</span></div></a></li><li class="depth-1 "><a href="05-Low-Level-Wrappers.html"><div class="inner"><span>Low-Level Wrappers</span></div></a></li><li class="depth-1 "><a href="50-Data-Model.html"><div class="inner"><span>Data Model</span></div></a></li><li class="depth-1 "><a href="99-Benchmarks.html"><div class="inner"><span>Benchmarks **OUTDATED**</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#memory-management" id="memory-management"></a>Memory Management</h1>
 <p>In order to serialize any non-primitive type, off-heap memory needs to be allocated. When memory is allocated inside the JVM, the memory is associated with an arena. If none is provided, the arena is an implicit arena, and the memory will be freed when the serialized object is garbage collected.</p>
 <p>In many cases this is not desirable, because the memory is not freed in a deterministic manner, causing garbage collection pauses to become longer, as well as changing allocation performance. Instead of an implicit arena, there are other kinds of arenas as well. A <code>confined-arena</code> is a thread-local arena. Confined arenas are <code>Closeable</code>, which means they should usually be used in a <code>with-open</code> form. When a <code>confined-arena</code> is closed, it immediately frees all the memory associated with it. The previous example, <code>out-int</code>, can be implemented with a confined arena.</p>
 <pre><code class="language-clojure">(defcfn out-int
diff --git a/docs/03-Builtin-Types.html b/docs/03-Builtin-Types.html
index ca6ec7d..0222e5a 100644
--- a/docs/03-Builtin-Types.html
+++ b/docs/03-Builtin-Types.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Built-in Types</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li><li class="depth-1 "><a href="02-Memory-Management.html"><div class="inner"><span>Memory Management</span></div></a></li><li class="depth-1  current"><a href="03-Builtin-Types.html"><div class="inner"><span>Built-in Types</span></div></a></li><li class="depth-1 "><a href="04-Custom-Types.html"><div class="inner"><span>Custom Types</span></div></a></li><li class="depth-1 "><a href="05-Low-Level-Wrappers.html"><div class="inner"><span>Low-Level Wrappers</span></div></a></li><li class="depth-1 "><a href="50-Data-Model.html"><div class="inner"><span>Data Model</span></div></a></li><li class="depth-1 "><a href="99-Benchmarks.html"><div class="inner"><span>Benchmarks</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#built-in-types" id="built-in-types"></a>Built-in Types</h1>
+<html><head><meta charset="UTF-8" /><title>Built-in Types **WIP**</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li><li class="depth-1 "><a href="02-Memory-Management.html"><div class="inner"><span>Memory Management</span></div></a></li><li class="depth-1  current"><a href="03-Builtin-Types.html"><div class="inner"><span>Built-in Types **WIP**</span></div></a></li><li class="depth-1 "><a href="04-Custom-Types.html"><div class="inner"><span>Custom Types</span></div></a></li><li class="depth-1 "><a href="05-Low-Level-Wrappers.html"><div class="inner"><span>Low-Level Wrappers</span></div></a></li><li class="depth-1 "><a href="50-Data-Model.html"><div class="inner"><span>Data Model</span></div></a></li><li class="depth-1 "><a href="99-Benchmarks.html"><div class="inner"><span>Benchmarks **OUTDATED**</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#built-in-types-wip" id="built-in-types-wip"></a>Built-in Types <strong>WIP</strong></h1>
 <h3><a href="#primitives" id="primitives"></a>Primitives</h3>
 <h3><a href="#arrays" id="arrays"></a>Arrays</h3>
 <h3><a href="#pointers" id="pointers"></a>Pointers</h3>
diff --git a/docs/04-Custom-Types.html b/docs/04-Custom-Types.html
index 50e6805..3194169 100644
--- a/docs/04-Custom-Types.html
+++ b/docs/04-Custom-Types.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Custom Types</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li><li class="depth-1 "><a href="02-Memory-Management.html"><div class="inner"><span>Memory Management</span></div></a></li><li class="depth-1 "><a href="03-Builtin-Types.html"><div class="inner"><span>Built-in Types</span></div></a></li><li class="depth-1  current"><a href="04-Custom-Types.html"><div class="inner"><span>Custom Types</span></div></a></li><li class="depth-1 "><a href="05-Low-Level-Wrappers.html"><div class="inner"><span>Low-Level Wrappers</span></div></a></li><li class="depth-1 "><a href="50-Data-Model.html"><div class="inner"><span>Data Model</span></div></a></li><li class="depth-1 "><a href="99-Benchmarks.html"><div class="inner"><span>Benchmarks</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#custom-types" id="custom-types"></a>Custom Types</h1>
+<html><head><meta charset="UTF-8" /><title>Custom Types</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li><li class="depth-1 "><a href="02-Memory-Management.html"><div class="inner"><span>Memory Management</span></div></a></li><li class="depth-1 "><a href="03-Builtin-Types.html"><div class="inner"><span>Built-in Types **WIP**</span></div></a></li><li class="depth-1  current"><a href="04-Custom-Types.html"><div class="inner"><span>Custom Types</span></div></a></li><li class="depth-1 "><a href="05-Low-Level-Wrappers.html"><div class="inner"><span>Low-Level Wrappers</span></div></a></li><li class="depth-1 "><a href="50-Data-Model.html"><div class="inner"><span>Data Model</span></div></a></li><li class="depth-1 "><a href="99-Benchmarks.html"><div class="inner"><span>Benchmarks **OUTDATED**</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#custom-types" id="custom-types"></a>Custom Types</h1>
 <p>Custom types with serializers and deserializers may be created. This is done using two sets of three multimethods which can be extended by the user. For any given type, only one set need be implemented.</p>
 <p>Two examples of custom types are given here, one is a 3d vector, and the other an example of a tagged union.</p>
 <h3><a href="#vector3" id="vector3"></a>Vector3</h3>
diff --git a/docs/05-Low-Level-Wrappers.html b/docs/05-Low-Level-Wrappers.html
index 0b9ab2c..6539b51 100644
--- a/docs/05-Low-Level-Wrappers.html
+++ b/docs/05-Low-Level-Wrappers.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Low-Level Wrappers</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li><li class="depth-1 "><a href="02-Memory-Management.html"><div class="inner"><span>Memory Management</span></div></a></li><li class="depth-1 "><a href="03-Builtin-Types.html"><div class="inner"><span>Built-in Types</span></div></a></li><li class="depth-1 "><a href="04-Custom-Types.html"><div class="inner"><span>Custom Types</span></div></a></li><li class="depth-1  current"><a href="05-Low-Level-Wrappers.html"><div class="inner"><span>Low-Level Wrappers</span></div></a></li><li class="depth-1 "><a href="50-Data-Model.html"><div class="inner"><span>Data Model</span></div></a></li><li class="depth-1 "><a href="99-Benchmarks.html"><div class="inner"><span>Benchmarks</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#low-level-wrappers" id="low-level-wrappers"></a>Low-Level Wrappers</h1>
+<html><head><meta charset="UTF-8" /><title>Low-Level Wrappers</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li><li class="depth-1 "><a href="02-Memory-Management.html"><div class="inner"><span>Memory Management</span></div></a></li><li class="depth-1 "><a href="03-Builtin-Types.html"><div class="inner"><span>Built-in Types **WIP**</span></div></a></li><li class="depth-1 "><a href="04-Custom-Types.html"><div class="inner"><span>Custom Types</span></div></a></li><li class="depth-1  current"><a href="05-Low-Level-Wrappers.html"><div class="inner"><span>Low-Level Wrappers</span></div></a></li><li class="depth-1 "><a href="50-Data-Model.html"><div class="inner"><span>Data Model</span></div></a></li><li class="depth-1 "><a href="99-Benchmarks.html"><div class="inner"><span>Benchmarks **OUTDATED**</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#low-level-wrappers" id="low-level-wrappers"></a>Low-Level Wrappers</h1>
 <h3><a href="#unwrapped-native-handles" id="unwrapped-native-handles"></a>Unwrapped Native Handles</h3>
 <p>Some native libraries work with handles to large amounts of data at once, making it undesirable to marshal data back and forth from Clojure, both because it’s not necessary to work with the data in Clojure directly, or also because of the high (de)serialization costs associated with marshaling. In cases like these, unwrapped native handles are desirable.</p>
 <p>The functions <code>make-downcall</code> and <code>make-varargs-factory</code> are also provided to create raw function handles.</p>
diff --git a/docs/50-Data-Model.html b/docs/50-Data-Model.html
index aba841f..79468a1 100644
--- a/docs/50-Data-Model.html
+++ b/docs/50-Data-Model.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Data Model</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li><li class="depth-1 "><a href="02-Memory-Management.html"><div class="inner"><span>Memory Management</span></div></a></li><li class="depth-1 "><a href="03-Builtin-Types.html"><div class="inner"><span>Built-in Types</span></div></a></li><li class="depth-1 "><a href="04-Custom-Types.html"><div class="inner"><span>Custom Types</span></div></a></li><li class="depth-1 "><a href="05-Low-Level-Wrappers.html"><div class="inner"><span>Low-Level Wrappers</span></div></a></li><li class="depth-1  current"><a href="50-Data-Model.html"><div class="inner"><span>Data Model</span></div></a></li><li class="depth-1 "><a href="99-Benchmarks.html"><div class="inner"><span>Benchmarks</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#data-model" id="data-model"></a>Data Model</h1>
+<html><head><meta charset="UTF-8" /><title>Data Model</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li><li class="depth-1 "><a href="02-Memory-Management.html"><div class="inner"><span>Memory Management</span></div></a></li><li class="depth-1 "><a href="03-Builtin-Types.html"><div class="inner"><span>Built-in Types **WIP**</span></div></a></li><li class="depth-1 "><a href="04-Custom-Types.html"><div class="inner"><span>Custom Types</span></div></a></li><li class="depth-1 "><a href="05-Low-Level-Wrappers.html"><div class="inner"><span>Low-Level Wrappers</span></div></a></li><li class="depth-1  current"><a href="50-Data-Model.html"><div class="inner"><span>Data Model</span></div></a></li><li class="depth-1 "><a href="99-Benchmarks.html"><div class="inner"><span>Benchmarks **OUTDATED**</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#data-model" id="data-model"></a>Data Model</h1>
 <p>In addition to the macros and functions provided to build a Clojure API for native libraries, facilities are provided for taking data and loading all the symbols specified by it. This can be useful if a library provides (or an external provider maintains) a data representation of their API, as Clojure data to represent it may be programmatically generated from these sources.</p>
 <p>The data to represent an API is a map with the following form:</p>
 <pre><code class="language-clojure">(def strlen-libspec
diff --git a/docs/99-Benchmarks.html b/docs/99-Benchmarks.html
index 0009067..94fd620 100644
--- a/docs/99-Benchmarks.html
+++ b/docs/99-Benchmarks.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Benchmarks</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li><li class="depth-1 "><a href="02-Memory-Management.html"><div class="inner"><span>Memory Management</span></div></a></li><li class="depth-1 "><a href="03-Builtin-Types.html"><div class="inner"><span>Built-in Types</span></div></a></li><li class="depth-1 "><a href="04-Custom-Types.html"><div class="inner"><span>Custom Types</span></div></a></li><li class="depth-1 "><a href="05-Low-Level-Wrappers.html"><div class="inner"><span>Low-Level Wrappers</span></div></a></li><li class="depth-1 "><a href="50-Data-Model.html"><div class="inner"><span>Data Model</span></div></a></li><li class="depth-1  current"><a href="99-Benchmarks.html"><div class="inner"><span>Benchmarks</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#benchmarks" id="benchmarks"></a>Benchmarks</h1>
+<html><head><meta charset="UTF-8" /><title>Benchmarks **OUTDATED**</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li><li class="depth-1 "><a href="02-Memory-Management.html"><div class="inner"><span>Memory Management</span></div></a></li><li class="depth-1 "><a href="03-Builtin-Types.html"><div class="inner"><span>Built-in Types **WIP**</span></div></a></li><li class="depth-1 "><a href="04-Custom-Types.html"><div class="inner"><span>Custom Types</span></div></a></li><li class="depth-1 "><a href="05-Low-Level-Wrappers.html"><div class="inner"><span>Low-Level Wrappers</span></div></a></li><li class="depth-1 "><a href="50-Data-Model.html"><div class="inner"><span>Data Model</span></div></a></li><li class="depth-1  current"><a href="99-Benchmarks.html"><div class="inner"><span>Benchmarks **OUTDATED**</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#benchmarks-outdated" id="benchmarks-outdated"></a>Benchmarks <strong>OUTDATED</strong></h1>
 <p><strong>BENCHMARKS FOR COFFI AND DTYPE-NEXT ARE BASED ON AN OLD VERSION. NEW BENCHMARKS WILL BE CREATED SOON.</strong></p>
 <p>An additional consideration when thinking about alternatives is the performance of each available option. It’s an established fact that JNA (used by all three alternative libraries on JDK &lt;16) introduces more overhead when calling native code than JNI does.</p>
 <p>In order to provide a benchmark to see how much of a difference the different native interfaces make, we can use <a href="https://github.com/hugoduncan/criterium">criterium</a> to benchmark each. <a href="https://www.glfw.org">GLFW</a>’s <a href="https://www.glfw.org/docs/latest/group__input.html#gaa6cf4e7a77158a3b8fd00328b1720a4a"><code>glfwGetTime</code></a> function will be used for the test as it performs a simple operation, and is conveniently already wrapped in JNI by the excellent <a href="https://www.lwjgl.org/">LWJGL</a> library.</p>
diff --git a/docs/articles/01-Getting-Started.md b/docs/articles/01-Getting-Started.md
index 6fb3cc6..1374b52 100644
--- a/docs/articles/01-Getting-Started.md
+++ b/docs/articles/01-Getting-Started.md
@@ -109,6 +109,7 @@ being able to be loaded.
 
 ### Primitive Types
 Coffi defines a basic set of primitive types:
+
 - byte
 - short
 - int
diff --git a/docs/articles/03-Builtin-Types.md b/docs/articles/03-Builtin-Types.md
index 81d8cfb..03bb8c8 100644
--- a/docs/articles/03-Builtin-Types.md
+++ b/docs/articles/03-Builtin-Types.md
@@ -1,4 +1,4 @@
-# Built-in Types
+# Built-in Types **WIP**
 
 ### Primitives
 
diff --git a/docs/articles/99-Benchmarks.md b/docs/articles/99-Benchmarks.md
index 69ef11c..6e30eff 100644
--- a/docs/articles/99-Benchmarks.md
+++ b/docs/articles/99-Benchmarks.md
@@ -1,4 +1,4 @@
-# Benchmarks
+# Benchmarks **OUTDATED**
 **BENCHMARKS FOR COFFI AND DTYPE-NEXT ARE BASED ON AN OLD VERSION. NEW BENCHMARKS WILL BE CREATED SOON.**
 
 An additional consideration when thinking about alternatives is the performance
diff --git a/docs/coffi.ffi.html b/docs/coffi.ffi.html
index c911409..975a489 100644
--- a/docs/coffi.ffi.html
+++ b/docs/coffi.ffi.html
@@ -1,41 +1,41 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>coffi.ffi documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li><li class="depth-1 "><a href="02-Memory-Management.html"><div class="inner"><span>Memory Management</span></div></a></li><li class="depth-1 "><a href="03-Builtin-Types.html"><div class="inner"><span>Built-in Types</span></div></a></li><li class="depth-1 "><a href="04-Custom-Types.html"><div class="inner"><span>Custom Types</span></div></a></li><li class="depth-1 "><a href="05-Low-Level-Wrappers.html"><div class="inner"><span>Low-Level Wrappers</span></div></a></li><li class="depth-1 "><a href="50-Data-Model.html"><div class="inner"><span>Data Model</span></div></a></li><li class="depth-1 "><a href="99-Benchmarks.html"><div class="inner"><span>Benchmarks</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch current"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="coffi.ffi.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-const"><div class="inner"><span>const</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-defcfn"><div class="inner"><span>defcfn</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-defconst"><div class="inner"><span>defconst</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-defvar"><div class="inner"><span>defvar</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-ensure-symbol"><div class="inner"><span>ensure-symbol</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-find-symbol"><div class="inner"><span>find-symbol</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-freset.21"><div class="inner"><span>freset!</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-fswap.21"><div class="inner"><span>fswap!</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-load-library"><div class="inner"><span>load-library</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-load-system-library"><div class="inner"><span>load-system-library</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-make-downcall"><div class="inner"><span>make-downcall</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-make-serde-varargs-wrapper"><div class="inner"><span>make-serde-varargs-wrapper</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-make-serde-wrapper"><div class="inner"><span>make-serde-wrapper</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-make-varargs-factory"><div class="inner"><span>make-varargs-factory</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-reify-libspec"><div class="inner"><span>reify-libspec</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-reify-symbolspec"><div class="inner"><span>reify-symbolspec</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-static-variable"><div class="inner"><span>static-variable</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-static-variable-segment"><div class="inner"><span>static-variable-segment</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-vacfn-factory"><div class="inner"><span>vacfn-factory</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">coffi.ffi</h1><div class="doc"><div class="markdown"><p>Functions for creating handles to native functions and loading native libraries.</p>
+<html><head><meta charset="UTF-8" /><title>coffi.ffi documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li><li class="depth-1 "><a href="02-Memory-Management.html"><div class="inner"><span>Memory Management</span></div></a></li><li class="depth-1 "><a href="03-Builtin-Types.html"><div class="inner"><span>Built-in Types **WIP**</span></div></a></li><li class="depth-1 "><a href="04-Custom-Types.html"><div class="inner"><span>Custom Types</span></div></a></li><li class="depth-1 "><a href="05-Low-Level-Wrappers.html"><div class="inner"><span>Low-Level Wrappers</span></div></a></li><li class="depth-1 "><a href="50-Data-Model.html"><div class="inner"><span>Data Model</span></div></a></li><li class="depth-1 "><a href="99-Benchmarks.html"><div class="inner"><span>Benchmarks **OUTDATED**</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch current"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="coffi.ffi.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-const"><div class="inner"><span>const</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-defcfn"><div class="inner"><span>defcfn</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-defconst"><div class="inner"><span>defconst</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-defvar"><div class="inner"><span>defvar</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-ensure-symbol"><div class="inner"><span>ensure-symbol</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-find-symbol"><div class="inner"><span>find-symbol</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-freset.21"><div class="inner"><span>freset!</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-fswap.21"><div class="inner"><span>fswap!</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-load-library"><div class="inner"><span>load-library</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-load-system-library"><div class="inner"><span>load-system-library</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-make-downcall"><div class="inner"><span>make-downcall</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-make-serde-varargs-wrapper"><div class="inner"><span>make-serde-varargs-wrapper</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-make-serde-wrapper"><div class="inner"><span>make-serde-wrapper</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-make-varargs-factory"><div class="inner"><span>make-varargs-factory</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-reify-libspec"><div class="inner"><span>reify-libspec</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-reify-symbolspec"><div class="inner"><span>reify-symbolspec</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-static-variable"><div class="inner"><span>static-variable</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-static-variable-segment"><div class="inner"><span>static-variable-segment</span></div></a></li><li class="depth-1"><a href="coffi.ffi.html#var-vacfn-factory"><div class="inner"><span>vacfn-factory</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">coffi.ffi</h1><div class="doc"><div class="markdown"><p>Functions for creating handles to native functions and loading native libraries.</p>
 </div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn symbol args ret)</code></div><div class="doc"><div class="markdown"><p>Constructs a Clojure function to call the native function referenced by <code>symbol</code>.</p>
 <p>The function returned will serialize any passed arguments into the <code>args</code> types, and deserialize the return to the <code>ret</code> type.</p>
 <p>If your <code>args</code> and <code>ret</code> are constants, then it is more efficient to call <a href="coffi.ffi.html#var-make-downcall">make-downcall</a> followed by <a href="coffi.ffi.html#var-make-serde-wrapper">make-serde-wrapper</a> because the latter has an inline definition which will result in less overhead from serdes.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/ffi.clj#L438">view source</a></div></div><div class="public anchor" id="var-const"><h3>const</h3><div class="usage"><code>(const symbol-or-addr type)</code></div><div class="doc"><div class="markdown"><p>Gets the value of a constant stored in <code>symbol-or-addr</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/ffi.clj#L606">view source</a></div></div><div class="public anchor" id="var-defcfn"><h3>defcfn</h3><h4 class="type">macro</h4><div class="usage"><code>(defcfn name docstring? attr-map? symbol arg-types ret-type)</code><code>(defcfn name docstring? attr-map? symbol arg-types ret-type native-fn &amp; fn-tail)</code></div><div class="doc"><div class="markdown"><p>Defines a Clojure function which maps to a native function.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/ffi.clj#L438">view source</a></div></div><div class="public anchor" id="var-const"><h3>const</h3><div class="usage"><code>(const symbol-or-addr type)</code></div><div class="doc"><div class="markdown"><p>Gets the value of a constant stored in <code>symbol-or-addr</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/ffi.clj#L606">view source</a></div></div><div class="public anchor" id="var-defcfn"><h3>defcfn</h3><h4 class="type">macro</h4><div class="usage"><code>(defcfn name docstring? attr-map? symbol arg-types ret-type)</code><code>(defcfn name docstring? attr-map? symbol arg-types ret-type native-fn &amp; fn-tail)</code></div><div class="doc"><div class="markdown"><p>Defines a Clojure function which maps to a native function.</p>
 <p><code>name</code> is the symbol naming the resulting var. <code>symbol</code> is a symbol or string naming the library symbol to link against. <code>arg-types</code> is a vector of qualified keywords representing the argument types. <code>ret-type</code> is a single qualified keyword representing the return type. <code>fn-tail</code> is the body of the function (potentially with multiple arities) which wraps the native one. Inside the function, <code>native-fn</code> is bound to a function that will serialize its arguments, call the native function, and deserialize its return type. If any body is present, you must call this function in order to call the native code.</p>
 <p>If no <code>fn-tail</code> is provided, then the resulting function will simply serialize the arguments according to <code>arg-types</code>, call the native function, and deserialize the return value.</p>
 <p>The number of args in the <code>fn-tail</code> need not match the number of <code>arg-types</code> for the native function. It need only call the native wrapper function with the correct arguments.</p>
 <p>See <a href="coffi.mem.html#var-serialize">serialize</a>, <a href="coffi.mem.html#var-deserialize">deserialize</a>, <a href="coffi.ffi.html#var-make-downcall">make-downcall</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/ffi.clj#L780">view source</a></div></div><div class="public anchor" id="var-defconst"><h3>defconst</h3><h4 class="type">macro</h4><div class="usage"><code>(defconst symbol docstring? symbol-or-addr type)</code></div><div class="doc"><div class="markdown"><p>Defines a var named by <code>symbol</code> to be the value of the given <code>type</code> from <code>symbol-or-addr</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/ffi.clj#L617">view source</a></div></div><div class="public anchor" id="var-defvar"><h3>defvar</h3><h4 class="type">macro</h4><div class="usage"><code>(defvar symbol docstring? symbol-or-addr type)</code></div><div class="doc"><div class="markdown"><p>Defines a var named by <code>symbol</code> to be a reference to the native memory from <code>symbol-or-addr</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/ffi.clj#L683">view source</a></div></div><div class="public anchor" id="var-ensure-symbol"><h3>ensure-symbol</h3><div class="usage"><code>(ensure-symbol symbol-or-addr)</code></div><div class="doc"><div class="markdown"><p>Returns the argument if it is a <a href="null">MemorySegment</a>, otherwise calls <a href="coffi.ffi.html#var-find-symbol">find-symbol</a> on it.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/ffi.clj#L198">view source</a></div></div><div class="public anchor" id="var-find-symbol"><h3>find-symbol</h3><div class="usage"><code>(find-symbol sym)</code></div><div class="doc"><div class="markdown"><p>Gets the <a href="null">MemorySegment</a> of a symbol from the loaded libraries.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/ffi.clj#L38">view source</a></div></div><div class="public anchor" id="var-freset.21"><h3>freset!</h3><div class="usage"><code>(freset! static-var newval)</code></div><div class="doc"><div class="markdown"><p>Sets the value of <code>static-var</code> to <code>newval</code>, running it through <a href="coffi.mem.html#var-serialize">serialize</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/ffi.clj#L647">view source</a></div></div><div class="public anchor" id="var-fswap.21"><h3>fswap!</h3><div class="usage"><code>(fswap! static-var f &amp; args)</code></div><div class="doc"><div class="markdown"><p>Non-atomically runs the function <code>f</code> over the value stored in <code>static-var</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/ffi.clj#L780">view source</a></div></div><div class="public anchor" id="var-defconst"><h3>defconst</h3><h4 class="type">macro</h4><div class="usage"><code>(defconst symbol docstring? symbol-or-addr type)</code></div><div class="doc"><div class="markdown"><p>Defines a var named by <code>symbol</code> to be the value of the given <code>type</code> from <code>symbol-or-addr</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/ffi.clj#L617">view source</a></div></div><div class="public anchor" id="var-defvar"><h3>defvar</h3><h4 class="type">macro</h4><div class="usage"><code>(defvar symbol docstring? symbol-or-addr type)</code></div><div class="doc"><div class="markdown"><p>Defines a var named by <code>symbol</code> to be a reference to the native memory from <code>symbol-or-addr</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/ffi.clj#L683">view source</a></div></div><div class="public anchor" id="var-ensure-symbol"><h3>ensure-symbol</h3><div class="usage"><code>(ensure-symbol symbol-or-addr)</code></div><div class="doc"><div class="markdown"><p>Returns the argument if it is a <a href="null">MemorySegment</a>, otherwise calls <a href="coffi.ffi.html#var-find-symbol">find-symbol</a> on it.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/ffi.clj#L198">view source</a></div></div><div class="public anchor" id="var-find-symbol"><h3>find-symbol</h3><div class="usage"><code>(find-symbol sym)</code></div><div class="doc"><div class="markdown"><p>Gets the <a href="null">MemorySegment</a> of a symbol from the loaded libraries.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/ffi.clj#L38">view source</a></div></div><div class="public anchor" id="var-freset.21"><h3>freset!</h3><div class="usage"><code>(freset! static-var newval)</code></div><div class="doc"><div class="markdown"><p>Sets the value of <code>static-var</code> to <code>newval</code>, running it through <a href="coffi.mem.html#var-serialize">serialize</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/ffi.clj#L647">view source</a></div></div><div class="public anchor" id="var-fswap.21"><h3>fswap!</h3><div class="usage"><code>(fswap! static-var f &amp; args)</code></div><div class="doc"><div class="markdown"><p>Non-atomically runs the function <code>f</code> over the value stored in <code>static-var</code>.</p>
 <p>The value is deserialized before passing it to <code>f</code>, and serialized before putting the value into <code>static-var</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/ffi.clj#L656">view source</a></div></div><div class="public anchor" id="var-load-library"><h3>load-library</h3><div class="usage"><code>(load-library path)</code></div><div class="doc"><div class="markdown"><p>Loads the library at <code>path</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/ffi.clj#L33">view source</a></div></div><div class="public anchor" id="var-load-system-library"><h3>load-system-library</h3><div class="usage"><code>(load-system-library libname)</code></div><div class="doc"><div class="markdown"><p>Loads the library named <code>libname</code> from the system’s load path.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/ffi.clj#L28">view source</a></div></div><div class="public anchor" id="var-make-downcall"><h3>make-downcall</h3><div class="usage"><code>(make-downcall symbol-or-addr args ret)</code></div><div class="doc"><div class="markdown"><p>Constructs a downcall function reference to <code>symbol-or-addr</code> with the given <code>args</code> and <code>ret</code> types.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/ffi.clj#L656">view source</a></div></div><div class="public anchor" id="var-load-library"><h3>load-library</h3><div class="usage"><code>(load-library path)</code></div><div class="doc"><div class="markdown"><p>Loads the library at <code>path</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/ffi.clj#L33">view source</a></div></div><div class="public anchor" id="var-load-system-library"><h3>load-system-library</h3><div class="usage"><code>(load-system-library libname)</code></div><div class="doc"><div class="markdown"><p>Loads the library named <code>libname</code> from the system’s load path.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/ffi.clj#L28">view source</a></div></div><div class="public anchor" id="var-make-downcall"><h3>make-downcall</h3><div class="usage"><code>(make-downcall symbol-or-addr args ret)</code></div><div class="doc"><div class="markdown"><p>Constructs a downcall function reference to <code>symbol-or-addr</code> with the given <code>args</code> and <code>ret</code> types.</p>
 <p>The function returned takes only arguments whose types match exactly the <a href="coffi.mem.html#var-java-layout">java-layout</a> for that type, and returns an argument with exactly the <a href="coffi.mem.html#var-java-layout">java-layout</a> of the <code>ret</code> type. This function will perform no serialization or deserialization of arguments or the return type.</p>
 <p>If the <code>ret</code> type is non-primitive, then the returned function will take a first argument of a <a href="null">SegmentAllocator</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/ffi.clj#L206">view source</a></div></div><div class="public anchor" id="var-make-serde-varargs-wrapper"><h3>make-serde-varargs-wrapper</h3><div class="usage"><code>(make-serde-varargs-wrapper varargs-factory required-args ret-type)</code></div><div class="doc"><div class="markdown"><p>Constructs a wrapper function for the <code>varargs-factory</code> which produces functions that serialize the arguments and deserialize the return value.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/ffi.clj#L426">view source</a></div></div><div class="public anchor" id="var-make-serde-wrapper"><h3>make-serde-wrapper</h3><div class="usage"><code>(make-serde-wrapper downcall arg-types ret-type)</code></div><div class="doc"><div class="markdown"><p>Constructs a wrapper function for the <code>downcall</code> which serializes the arguments and deserializes the return value.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/ffi.clj#L407">view source</a></div></div><div class="public anchor" id="var-make-varargs-factory"><h3>make-varargs-factory</h3><div class="usage"><code>(make-varargs-factory symbol required-args ret)</code></div><div class="doc"><div class="markdown"><p>Returns a function for constructing downcalls with additional types for arguments.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/ffi.clj#L206">view source</a></div></div><div class="public anchor" id="var-make-serde-varargs-wrapper"><h3>make-serde-varargs-wrapper</h3><div class="usage"><code>(make-serde-varargs-wrapper varargs-factory required-args ret-type)</code></div><div class="doc"><div class="markdown"><p>Constructs a wrapper function for the <code>varargs-factory</code> which produces functions that serialize the arguments and deserialize the return value.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/ffi.clj#L426">view source</a></div></div><div class="public anchor" id="var-make-serde-wrapper"><h3>make-serde-wrapper</h3><div class="usage"><code>(make-serde-wrapper downcall arg-types ret-type)</code></div><div class="doc"><div class="markdown"><p>Constructs a wrapper function for the <code>downcall</code> which serializes the arguments and deserializes the return value.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/ffi.clj#L407">view source</a></div></div><div class="public anchor" id="var-make-varargs-factory"><h3>make-varargs-factory</h3><div class="usage"><code>(make-varargs-factory symbol required-args ret)</code></div><div class="doc"><div class="markdown"><p>Returns a function for constructing downcalls with additional types for arguments.</p>
 <p>The <code>required-args</code> are the types of the first arguments passed to the downcall handle, and the values passed to the returned function are only the varargs types.</p>
 <p>The returned function is memoized, so that only one downcall function will be generated per combination of argument types.</p>
 <p>See <a href="coffi.ffi.html#var-make-downcall">make-downcall</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/ffi.clj#L222">view source</a></div></div><div class="public anchor" id="var-reify-libspec"><h3>reify-libspec</h3><div class="usage"><code>(reify-libspec libspec)</code></div><div class="doc"><div class="markdown"><p>Loads all the symbols specified in the <code>libspec</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/ffi.clj#L222">view source</a></div></div><div class="public anchor" id="var-reify-libspec"><h3>reify-libspec</h3><div class="usage"><code>(reify-libspec libspec)</code></div><div class="doc"><div class="markdown"><p>Loads all the symbols specified in the <code>libspec</code>.</p>
 <p>The value of each key of the passed map is transformed as by <a href="coffi.ffi.html#var-reify-symbolspec">reify-symbolspec</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/ffi.clj#L742">view source</a></div></div><div class="public anchor" id="var-reify-symbolspec"><h3>reify-symbolspec</h3><h4 class="type">multimethod</h4><div class="usage"></div><div class="doc"><div class="markdown"><p>Takes a spec for a symbol reference and returns a live value for that type.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/ffi.clj#L701">view source</a></div></div><div class="public anchor" id="var-static-variable"><h3>static-variable</h3><div class="usage"><code>(static-variable symbol-or-addr type)</code></div><div class="doc"><div class="markdown"><p>Constructs a reference to a mutable value stored in <code>symbol-or-addr</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/ffi.clj#L742">view source</a></div></div><div class="public anchor" id="var-reify-symbolspec"><h3>reify-symbolspec</h3><h4 class="type">multimethod</h4><div class="usage"></div><div class="doc"><div class="markdown"><p>Takes a spec for a symbol reference and returns a live value for that type.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/ffi.clj#L701">view source</a></div></div><div class="public anchor" id="var-static-variable"><h3>static-variable</h3><div class="usage"><code>(static-variable symbol-or-addr type)</code></div><div class="doc"><div class="markdown"><p>Constructs a reference to a mutable value stored in <code>symbol-or-addr</code>.</p>
 <p>The returned value can be dereferenced, and has metadata.</p>
 <p>See <a href="coffi.ffi.html#var-freset.21">freset!</a>, <a href="coffi.ffi.html#var-fswap.21">fswap!</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/ffi.clj#L672">view source</a></div></div><div class="public anchor" id="var-static-variable-segment"><h3>static-variable-segment</h3><div class="usage"><code>(static-variable-segment static-var)</code></div><div class="doc"><div class="markdown"><p>Gets the backing <a href="null">MemorySegment</a> from <code>static-var</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/ffi.clj#L672">view source</a></div></div><div class="public anchor" id="var-static-variable-segment"><h3>static-variable-segment</h3><div class="usage"><code>(static-variable-segment static-var)</code></div><div class="doc"><div class="markdown"><p>Gets the backing <a href="null">MemorySegment</a> from <code>static-var</code>.</p>
 <p>This is primarily useful when you need to pass the static variable’s address to a native function which takes an <a href="null">Addressable</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/ffi.clj#L664">view source</a></div></div><div class="public anchor" id="var-vacfn-factory"><h3>vacfn-factory</h3><div class="usage"><code>(vacfn-factory symbol required-args ret)</code></div><div class="doc"><div class="markdown"><p>Constructs a varargs factory to call the native function referenced by <code>symbol</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/ffi.clj#L664">view source</a></div></div><div class="public anchor" id="var-vacfn-factory"><h3>vacfn-factory</h3><div class="usage"><code>(vacfn-factory symbol required-args ret)</code></div><div class="doc"><div class="markdown"><p>Constructs a varargs factory to call the native function referenced by <code>symbol</code>.</p>
 <p>The function returned takes any number of type arguments and returns a specialized Clojure function for calling the native function with those arguments.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/ffi.clj#L453">view source</a></div></div></div></body></html>
\ No newline at end of file
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/ffi.clj#L453">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/coffi.layout.html b/docs/coffi.layout.html
index 0783ab7..aaca13e 100644
--- a/docs/coffi.layout.html
+++ b/docs/coffi.layout.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>coffi.layout documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li><li class="depth-1 "><a href="02-Memory-Management.html"><div class="inner"><span>Memory Management</span></div></a></li><li class="depth-1 "><a href="03-Builtin-Types.html"><div class="inner"><span>Built-in Types</span></div></a></li><li class="depth-1 "><a href="04-Custom-Types.html"><div class="inner"><span>Custom Types</span></div></a></li><li class="depth-1 "><a href="05-Low-Level-Wrappers.html"><div class="inner"><span>Low-Level Wrappers</span></div></a></li><li class="depth-1 "><a href="50-Data-Model.html"><div class="inner"><span>Data Model</span></div></a></li><li class="depth-1 "><a href="99-Benchmarks.html"><div class="inner"><span>Benchmarks</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch current"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="coffi.layout.html#var-with-c-layout"><div class="inner"><span>with-c-layout</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">coffi.layout</h1><div class="doc"><div class="markdown"><p>Functions for adjusting the layout of structs.</p>
+<html><head><meta charset="UTF-8" /><title>coffi.layout documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li><li class="depth-1 "><a href="02-Memory-Management.html"><div class="inner"><span>Memory Management</span></div></a></li><li class="depth-1 "><a href="03-Builtin-Types.html"><div class="inner"><span>Built-in Types **WIP**</span></div></a></li><li class="depth-1 "><a href="04-Custom-Types.html"><div class="inner"><span>Custom Types</span></div></a></li><li class="depth-1 "><a href="05-Low-Level-Wrappers.html"><div class="inner"><span>Low-Level Wrappers</span></div></a></li><li class="depth-1 "><a href="50-Data-Model.html"><div class="inner"><span>Data Model</span></div></a></li><li class="depth-1 "><a href="99-Benchmarks.html"><div class="inner"><span>Benchmarks **OUTDATED**</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch current"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="coffi.layout.html#var-with-c-layout"><div class="inner"><span>with-c-layout</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">coffi.layout</h1><div class="doc"><div class="markdown"><p>Functions for adjusting the layout of structs.</p>
 </div></div><div class="public anchor" id="var-with-c-layout"><h3>with-c-layout</h3><div class="usage"><code>(with-c-layout struct-spec)</code></div><div class="doc"><div class="markdown"><p>Forces a struct specification to C layout rules.</p>
 <p>This will add padding fields between fields to match C alignment requirements.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/layout.clj#L6">view source</a></div></div></div></body></html>
\ No newline at end of file
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/layout.clj#L6">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/coffi.mem.html b/docs/coffi.mem.html
index 0afc416..b8f16b4 100644
--- a/docs/coffi.mem.html
+++ b/docs/coffi.mem.html
@@ -1,121 +1,121 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>coffi.mem documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li><li class="depth-1 "><a href="02-Memory-Management.html"><div class="inner"><span>Memory Management</span></div></a></li><li class="depth-1 "><a href="03-Builtin-Types.html"><div class="inner"><span>Built-in Types</span></div></a></li><li class="depth-1 "><a href="04-Custom-Types.html"><div class="inner"><span>Custom Types</span></div></a></li><li class="depth-1 "><a href="05-Low-Level-Wrappers.html"><div class="inner"><span>Low-Level Wrappers</span></div></a></li><li class="depth-1 "><a href="50-Data-Model.html"><div class="inner"><span>Data Model</span></div></a></li><li class="depth-1 "><a href="99-Benchmarks.html"><div class="inner"><span>Benchmarks</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2 current"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="coffi.mem.html#var-address-of"><div class="inner"><span>address-of</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-address.3F"><div class="inner"><span>address?</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-align-of"><div class="inner"><span>align-of</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-alloc"><div class="inner"><span>alloc</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-alloc-instance"><div class="inner"><span>alloc-instance</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-alloc-with"><div class="inner"><span>alloc-with</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-arena-allocator"><div class="inner"><span>arena-allocator</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-as-segment"><div class="inner"><span>as-segment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-auto-arena"><div class="inner"><span>auto-arena</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-big-endian"><div class="inner"><span>big-endian</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-byte-layout"><div class="inner"><span>byte-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-c-layout"><div class="inner"><span>c-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-char-layout"><div class="inner"><span>char-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-clone-segment"><div class="inner"><span>clone-segment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-confined-arena"><div class="inner"><span>confined-arena</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-copy-segment"><div class="inner"><span>copy-segment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-defalias"><div class="inner"><span>defalias</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-deserialize"><div class="inner"><span>deserialize</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-deserialize*"><div class="inner"><span>deserialize*</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-deserialize-from"><div class="inner"><span>deserialize-from</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-double-alignment"><div class="inner"><span>double-alignment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-double-layout"><div class="inner"><span>double-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-double-size"><div class="inner"><span>double-size</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-float-alignment"><div class="inner"><span>float-alignment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-float-layout"><div class="inner"><span>float-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-float-size"><div class="inner"><span>float-size</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-global-arena"><div class="inner"><span>global-arena</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-int-alignment"><div class="inner"><span>int-alignment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-int-layout"><div class="inner"><span>int-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-int-size"><div class="inner"><span>int-size</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-java-layout"><div class="inner"><span>java-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-java-prim-layout"><div class="inner"><span>java-prim-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-little-endian"><div class="inner"><span>little-endian</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-long-alignment"><div class="inner"><span>long-alignment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-long-layout"><div class="inner"><span>long-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-long-size"><div class="inner"><span>long-size</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-native-endian"><div class="inner"><span>native-endian</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-null"><div class="inner"><span>null</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-null.3F"><div class="inner"><span>null?</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-pointer-alignment"><div class="inner"><span>pointer-alignment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-pointer-layout"><div class="inner"><span>pointer-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-pointer-size"><div class="inner"><span>pointer-size</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-primitive-type"><div class="inner"><span>primitive-type</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-primitive-types"><div class="inner"><span>primitive-types</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-primitive.3F"><div class="inner"><span>primitive?</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-address"><div class="inner"><span>read-address</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-byte"><div class="inner"><span>read-byte</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-char"><div class="inner"><span>read-char</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-double"><div class="inner"><span>read-double</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-float"><div class="inner"><span>read-float</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-int"><div class="inner"><span>read-int</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-long"><div class="inner"><span>read-long</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-short"><div class="inner"><span>read-short</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-reinterpret"><div class="inner"><span>reinterpret</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-seq-of"><div class="inner"><span>seq-of</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-serialize"><div class="inner"><span>serialize</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-serialize*"><div class="inner"><span>serialize*</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-serialize-into"><div class="inner"><span>serialize-into</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-shared-arena"><div class="inner"><span>shared-arena</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-short-alignment"><div class="inner"><span>short-alignment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-short-layout"><div class="inner"><span>short-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-short-size"><div class="inner"><span>short-size</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-size-of"><div class="inner"><span>size-of</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-slice"><div class="inner"><span>slice</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-slice-segments"><div class="inner"><span>slice-segments</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-address"><div class="inner"><span>write-address</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-byte"><div class="inner"><span>write-byte</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-char"><div class="inner"><span>write-char</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-double"><div class="inner"><span>write-double</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-float"><div class="inner"><span>write-float</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-int"><div class="inner"><span>write-int</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-long"><div class="inner"><span>write-long</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-short"><div class="inner"><span>write-short</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">coffi.mem</h1><div class="doc"><div class="markdown"><p>Functions for managing native allocations, memory arenas, and (de)serialization.</p>
+<html><head><meta charset="UTF-8" /><title>coffi.mem documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li><li class="depth-1 "><a href="02-Memory-Management.html"><div class="inner"><span>Memory Management</span></div></a></li><li class="depth-1 "><a href="03-Builtin-Types.html"><div class="inner"><span>Built-in Types **WIP**</span></div></a></li><li class="depth-1 "><a href="04-Custom-Types.html"><div class="inner"><span>Custom Types</span></div></a></li><li class="depth-1 "><a href="05-Low-Level-Wrappers.html"><div class="inner"><span>Low-Level Wrappers</span></div></a></li><li class="depth-1 "><a href="50-Data-Model.html"><div class="inner"><span>Data Model</span></div></a></li><li class="depth-1 "><a href="99-Benchmarks.html"><div class="inner"><span>Benchmarks **OUTDATED**</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2 current"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="coffi.mem.html#var-address-of"><div class="inner"><span>address-of</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-address.3F"><div class="inner"><span>address?</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-align-of"><div class="inner"><span>align-of</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-alloc"><div class="inner"><span>alloc</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-alloc-instance"><div class="inner"><span>alloc-instance</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-alloc-with"><div class="inner"><span>alloc-with</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-arena-allocator"><div class="inner"><span>arena-allocator</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-as-segment"><div class="inner"><span>as-segment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-auto-arena"><div class="inner"><span>auto-arena</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-big-endian"><div class="inner"><span>big-endian</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-byte-layout"><div class="inner"><span>byte-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-c-layout"><div class="inner"><span>c-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-char-layout"><div class="inner"><span>char-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-clone-segment"><div class="inner"><span>clone-segment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-confined-arena"><div class="inner"><span>confined-arena</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-copy-segment"><div class="inner"><span>copy-segment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-defalias"><div class="inner"><span>defalias</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-deserialize"><div class="inner"><span>deserialize</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-deserialize*"><div class="inner"><span>deserialize*</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-deserialize-from"><div class="inner"><span>deserialize-from</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-double-alignment"><div class="inner"><span>double-alignment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-double-layout"><div class="inner"><span>double-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-double-size"><div class="inner"><span>double-size</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-float-alignment"><div class="inner"><span>float-alignment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-float-layout"><div class="inner"><span>float-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-float-size"><div class="inner"><span>float-size</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-global-arena"><div class="inner"><span>global-arena</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-int-alignment"><div class="inner"><span>int-alignment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-int-layout"><div class="inner"><span>int-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-int-size"><div class="inner"><span>int-size</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-java-layout"><div class="inner"><span>java-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-java-prim-layout"><div class="inner"><span>java-prim-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-little-endian"><div class="inner"><span>little-endian</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-long-alignment"><div class="inner"><span>long-alignment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-long-layout"><div class="inner"><span>long-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-long-size"><div class="inner"><span>long-size</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-native-endian"><div class="inner"><span>native-endian</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-null"><div class="inner"><span>null</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-null.3F"><div class="inner"><span>null?</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-pointer-alignment"><div class="inner"><span>pointer-alignment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-pointer-layout"><div class="inner"><span>pointer-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-pointer-size"><div class="inner"><span>pointer-size</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-primitive-type"><div class="inner"><span>primitive-type</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-primitive-types"><div class="inner"><span>primitive-types</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-primitive.3F"><div class="inner"><span>primitive?</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-address"><div class="inner"><span>read-address</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-byte"><div class="inner"><span>read-byte</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-char"><div class="inner"><span>read-char</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-double"><div class="inner"><span>read-double</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-float"><div class="inner"><span>read-float</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-int"><div class="inner"><span>read-int</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-long"><div class="inner"><span>read-long</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-read-short"><div class="inner"><span>read-short</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-reinterpret"><div class="inner"><span>reinterpret</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-seq-of"><div class="inner"><span>seq-of</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-serialize"><div class="inner"><span>serialize</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-serialize*"><div class="inner"><span>serialize*</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-serialize-into"><div class="inner"><span>serialize-into</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-shared-arena"><div class="inner"><span>shared-arena</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-short-alignment"><div class="inner"><span>short-alignment</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-short-layout"><div class="inner"><span>short-layout</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-short-size"><div class="inner"><span>short-size</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-size-of"><div class="inner"><span>size-of</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-slice"><div class="inner"><span>slice</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-slice-segments"><div class="inner"><span>slice-segments</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-address"><div class="inner"><span>write-address</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-byte"><div class="inner"><span>write-byte</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-char"><div class="inner"><span>write-char</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-double"><div class="inner"><span>write-double</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-float"><div class="inner"><span>write-float</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-int"><div class="inner"><span>write-int</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-long"><div class="inner"><span>write-long</span></div></a></li><li class="depth-1"><a href="coffi.mem.html#var-write-short"><div class="inner"><span>write-short</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">coffi.mem</h1><div class="doc"><div class="markdown"><p>Functions for managing native allocations, memory arenas, and (de)serialization.</p>
 <p>For any new type to be implemented, three multimethods must be overriden, but which three depends on the native representation of the type.</p>
 <p>If the native representation of the type is a primitive (whether or not other data beyond the primitive is associated with it, as e.g. a pointer), then <a href="coffi.mem.html#var-primitive-type">primitive-type</a> must be overriden to return which primitive type it is serialized as, then <a href="coffi.mem.html#var-serialize*">serialize*</a> and <a href="coffi.mem.html#var-deserialize*">deserialize*</a> should be overriden.</p>
 <p>If the native representation of the type is a composite type, like a union, struct, or array, then <a href="coffi.mem.html#var-c-layout">c-layout</a> must be overriden to return the native layout of the type, and <a href="coffi.mem.html#var-serialize-into">serialize-into</a> and <a href="coffi.mem.html#var-deserialize-from">deserialize-from</a> should be overriden to allow marshaling values of the type into and out of memory segments.</p>
 </div></div><div class="public anchor" id="var-address-of"><h3>address-of</h3><div class="usage"><code>(address-of addressable)</code></div><div class="doc"><div class="markdown"><p>Gets the address of a given segment as a number.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L106">view source</a></div></div><div class="public anchor" id="var-address.3F"><h3>address?</h3><div class="usage"><code>(address? addr)</code></div><div class="doc"><div class="markdown"><p>Checks if an object is a memory address.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L106">view source</a></div></div><div class="public anchor" id="var-address.3F"><h3>address?</h3><div class="usage"><code>(address? addr)</code></div><div class="doc"><div class="markdown"><p>Checks if an object is a memory address.</p>
 <p><code>nil</code> is considered an address.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L124">view source</a></div></div><div class="public anchor" id="var-align-of"><h3>align-of</h3><div class="usage"><code>(align-of type)</code></div><div class="doc"><div class="markdown"><p>The alignment in bytes of the given <code>type</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L811">view source</a></div></div><div class="public anchor" id="var-alloc"><h3>alloc</h3><div class="usage"><code>(alloc size)</code><code>(alloc size arena)</code><code>(alloc size alignment arena)</code></div><div class="doc"><div class="markdown"><p>Allocates <code>size</code> bytes.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L124">view source</a></div></div><div class="public anchor" id="var-align-of"><h3>align-of</h3><div class="usage"><code>(align-of type)</code></div><div class="doc"><div class="markdown"><p>The alignment in bytes of the given <code>type</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L811">view source</a></div></div><div class="public anchor" id="var-alloc"><h3>alloc</h3><div class="usage"><code>(alloc size)</code><code>(alloc size arena)</code><code>(alloc size alignment arena)</code></div><div class="doc"><div class="markdown"><p>Allocates <code>size</code> bytes.</p>
 <p>If an <code>arena</code> is provided, the allocation will be reclaimed when it is closed.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L91">view source</a></div></div><div class="public anchor" id="var-alloc-instance"><h3>alloc-instance</h3><div class="usage"><code>(alloc-instance type)</code><code>(alloc-instance type arena)</code></div><div class="doc"><div class="markdown"><p>Allocates a memory segment for the given <code>type</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L818">view source</a></div></div><div class="public anchor" id="var-alloc-with"><h3>alloc-with</h3><div class="usage"><code>(alloc-with allocator size)</code><code>(alloc-with allocator size alignment)</code></div><div class="doc"><div class="markdown"><p>Allocates <code>size</code> bytes using the <code>allocator</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L99">view source</a></div></div><div class="public anchor" id="var-arena-allocator"><h3>arena-allocator</h3><div class="usage"><code>(arena-allocator arena)</code></div><div class="doc"><div class="markdown"><p>Constructs a <a href="null">SegmentAllocator</a> from the given <a href="null">Arena</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L91">view source</a></div></div><div class="public anchor" id="var-alloc-instance"><h3>alloc-instance</h3><div class="usage"><code>(alloc-instance type)</code><code>(alloc-instance type arena)</code></div><div class="doc"><div class="markdown"><p>Allocates a memory segment for the given <code>type</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L818">view source</a></div></div><div class="public anchor" id="var-alloc-with"><h3>alloc-with</h3><div class="usage"><code>(alloc-with allocator size)</code><code>(alloc-with allocator size alignment)</code></div><div class="doc"><div class="markdown"><p>Allocates <code>size</code> bytes using the <code>allocator</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L99">view source</a></div></div><div class="public anchor" id="var-arena-allocator"><h3>arena-allocator</h3><div class="usage"><code>(arena-allocator arena)</code></div><div class="doc"><div class="markdown"><p>Constructs a <a href="null">SegmentAllocator</a> from the given <a href="null">Arena</a>.</p>
 <p>This is primarily used when working with unwrapped downcall functions. When a downcall function returns a non-primitive type, it must be provided with an allocator.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L80">view source</a></div></div><div class="public anchor" id="var-as-segment"><h3>as-segment</h3><div class="usage"><code>(as-segment address)</code><code>(as-segment address size)</code><code>(as-segment address size arena)</code><code>(as-segment address size arena cleanup)</code></div><div class="doc"><div class="markdown"><p>Dereferences an <code>address</code> into a memory segment associated with the <code>arena</code> (default global).</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L156">view source</a></div></div><div class="public anchor" id="var-auto-arena"><h3>auto-arena</h3><div class="usage"><code>(auto-arena)</code></div><div class="doc"><div class="markdown"><p>Constructs a new memory arena that is managed by the garbage collector.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L80">view source</a></div></div><div class="public anchor" id="var-as-segment"><h3>as-segment</h3><div class="usage"><code>(as-segment address)</code><code>(as-segment address size)</code><code>(as-segment address size arena)</code><code>(as-segment address size arena cleanup)</code></div><div class="doc"><div class="markdown"><p>Dereferences an <code>address</code> into a memory segment associated with the <code>arena</code> (default global).</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L156">view source</a></div></div><div class="public anchor" id="var-auto-arena"><h3>auto-arena</h3><div class="usage"><code>(auto-arena)</code></div><div class="doc"><div class="markdown"><p>Constructs a new memory arena that is managed by the garbage collector.</p>
 <p>The arena may be shared across threads, and all resources created with it will be cleaned up at the same time, when all references have been collected.</p>
 <p>This type of arena cannot be closed, and therefore should not be created in a <a href="null">with-open</a> clause.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L59">view source</a></div></div><div class="public anchor" id="var-big-endian"><h3>big-endian</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The big-endian <a href="null">ByteOrder</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L59">view source</a></div></div><div class="public anchor" id="var-big-endian"><h3>big-endian</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The big-endian <a href="null">ByteOrder</a>.</p>
 <p>See <a href="coffi.mem.html#var-little-endian">little-endian</a>, <a href="coffi.mem.html#var-native-endian">native-endian</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L187">view source</a></div></div><div class="public anchor" id="var-byte-layout"><h3>byte-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a byte in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L205">view source</a></div></div><div class="public anchor" id="var-c-layout"><h3>c-layout</h3><h4 class="type">multimethod</h4><div class="usage"></div><div class="doc"><div class="markdown"><p>Gets the layout object for a given <code>type</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L187">view source</a></div></div><div class="public anchor" id="var-byte-layout"><h3>byte-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a byte in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L205">view source</a></div></div><div class="public anchor" id="var-c-layout"><h3>c-layout</h3><h4 class="type">multimethod</h4><div class="usage"></div><div class="doc"><div class="markdown"><p>Gets the layout object for a given <code>type</code>.</p>
 <p>If a type is primitive it will return the appropriate primitive layout (see <a href="null">c-prim-layout</a>).</p>
 <p>Otherwise, it should return a <a href="null">GroupLayout</a> for the given type.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L729">view source</a></div></div><div class="public anchor" id="var-char-layout"><h3>char-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a c-sized char in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L221">view source</a></div></div><div class="public anchor" id="var-clone-segment"><h3>clone-segment</h3><div class="usage"><code>(clone-segment segment)</code><code>(clone-segment segment arena)</code></div><div class="doc"><div class="markdown"><p>Clones the content of <code>segment</code> into a new segment of the same size.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L174">view source</a></div></div><div class="public anchor" id="var-confined-arena"><h3>confined-arena</h3><div class="usage"><code>(confined-arena)</code></div><div class="doc"><div class="markdown"><p>Constructs a new arena for use only in this thread.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L729">view source</a></div></div><div class="public anchor" id="var-char-layout"><h3>char-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a c-sized char in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L221">view source</a></div></div><div class="public anchor" id="var-clone-segment"><h3>clone-segment</h3><div class="usage"><code>(clone-segment segment)</code><code>(clone-segment segment arena)</code></div><div class="doc"><div class="markdown"><p>Clones the content of <code>segment</code> into a new segment of the same size.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L174">view source</a></div></div><div class="public anchor" id="var-confined-arena"><h3>confined-arena</h3><div class="usage"><code>(confined-arena)</code></div><div class="doc"><div class="markdown"><p>Constructs a new arena for use only in this thread.</p>
 <p>The memory allocated within this arena is cheap to allocate, like a native stack.</p>
 <p>The memory allocated within this arena will be cleared once it is closed, so it is usually a good idea to create it in a <a href="null">with-open</a> clause.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L40">view source</a></div></div><div class="public anchor" id="var-copy-segment"><h3>copy-segment</h3><div class="usage"><code>(copy-segment dest src)</code></div><div class="doc"><div class="markdown"><p>Copies the content to <code>dest</code> from <code>src</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L40">view source</a></div></div><div class="public anchor" id="var-copy-segment"><h3>copy-segment</h3><div class="usage"><code>(copy-segment dest src)</code></div><div class="doc"><div class="markdown"><p>Copies the content to <code>dest</code> from <code>src</code>.</p>
 <p>Returns <code>dest</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L167">view source</a></div></div><div class="public anchor" id="var-defalias"><h3>defalias</h3><h4 class="type">macro</h4><div class="usage"><code>(defalias new-type aliased-type)</code></div><div class="doc"><div class="markdown"><p>Defines a type alias from <code>new-type</code> to <code>aliased-type</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L167">view source</a></div></div><div class="public anchor" id="var-defalias"><h3>defalias</h3><h4 class="type">macro</h4><div class="usage"><code>(defalias new-type aliased-type)</code></div><div class="doc"><div class="markdown"><p>Defines a type alias from <code>new-type</code> to <code>aliased-type</code>.</p>
 <p>This creates needed serialization and deserialization implementations for the aliased type.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L1319">view source</a></div></div><div class="public anchor" id="var-deserialize"><h3>deserialize</h3><div class="usage"><code>(deserialize obj type)</code></div><div class="doc"><div class="markdown"><p>Deserializes an arbitrary type.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L1319">view source</a></div></div><div class="public anchor" id="var-deserialize"><h3>deserialize</h3><div class="usage"><code>(deserialize obj type)</code></div><div class="doc"><div class="markdown"><p>Deserializes an arbitrary type.</p>
 <p>For types which have a primitive representation, this deserializes the primitive representation. For types which do not, this deserializes out of a segment.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L1092">view source</a></div></div><div class="public anchor" id="var-deserialize*"><h3>deserialize*</h3><h4 class="type">multimethod</h4><div class="usage"></div><div class="doc"><div class="markdown"><p>Deserializes a primitive object into a Clojure data structure.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L1092">view source</a></div></div><div class="public anchor" id="var-deserialize*"><h3>deserialize*</h3><h4 class="type">multimethod</h4><div class="usage"></div><div class="doc"><div class="markdown"><p>Deserializes a primitive object into a Clojure data structure.</p>
 <p>This is intended for use with types that are returned as a primitive but which need additional processing before they can be returned.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L1033">view source</a></div></div><div class="public anchor" id="var-deserialize-from"><h3>deserialize-from</h3><h4 class="type">multimethod</h4><div class="usage"></div><div class="doc"><div class="markdown"><p>Deserializes the given segment into a Clojure data structure.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L1033">view source</a></div></div><div class="public anchor" id="var-deserialize-from"><h3>deserialize-from</h3><h4 class="type">multimethod</h4><div class="usage"></div><div class="doc"><div class="markdown"><p>Deserializes the given segment into a Clojure data structure.</p>
 <p>For types that serialize to primitives, a default implementation will deserialize the primitive before calling <a href="coffi.mem.html#var-deserialize*">deserialize*</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L970">view source</a></div></div><div class="public anchor" id="var-double-alignment"><h3>double-alignment</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The alignment in bytes of a c-sized double.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L277">view source</a></div></div><div class="public anchor" id="var-double-layout"><h3>double-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a c-sized double in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L229">view source</a></div></div><div class="public anchor" id="var-double-size"><h3>double-size</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The size in bytes of a c-sized double.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L253">view source</a></div></div><div class="public anchor" id="var-float-alignment"><h3>float-alignment</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The alignment in bytes of a c-sized float.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L273">view source</a></div></div><div class="public anchor" id="var-float-layout"><h3>float-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a c-sized float in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L225">view source</a></div></div><div class="public anchor" id="var-float-size"><h3>float-size</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The size in bytes of a c-sized float.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L249">view source</a></div></div><div class="public anchor" id="var-global-arena"><h3>global-arena</h3><div class="usage"><code>(global-arena)</code></div><div class="doc"><div class="markdown"><p>Constructs the global arena, which will never reclaim its resources.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L970">view source</a></div></div><div class="public anchor" id="var-double-alignment"><h3>double-alignment</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The alignment in bytes of a c-sized double.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L277">view source</a></div></div><div class="public anchor" id="var-double-layout"><h3>double-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a c-sized double in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L229">view source</a></div></div><div class="public anchor" id="var-double-size"><h3>double-size</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The size in bytes of a c-sized double.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L253">view source</a></div></div><div class="public anchor" id="var-float-alignment"><h3>float-alignment</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The alignment in bytes of a c-sized float.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L273">view source</a></div></div><div class="public anchor" id="var-float-layout"><h3>float-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a c-sized float in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L225">view source</a></div></div><div class="public anchor" id="var-float-size"><h3>float-size</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The size in bytes of a c-sized float.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L249">view source</a></div></div><div class="public anchor" id="var-global-arena"><h3>global-arena</h3><div class="usage"><code>(global-arena)</code></div><div class="doc"><div class="markdown"><p>Constructs the global arena, which will never reclaim its resources.</p>
 <p>This arena may be shared across threads, but is intended mainly in cases where memory is allocated with <a href="coffi.mem.html#var-alloc">alloc</a> but is either never freed or whose management is relinquished to a native library, such as when returned from a callback.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L70">view source</a></div></div><div class="public anchor" id="var-int-alignment"><h3>int-alignment</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The alignment in bytes of a c-sized int.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L265">view source</a></div></div><div class="public anchor" id="var-int-layout"><h3>int-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a c-sized int in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L213">view source</a></div></div><div class="public anchor" id="var-int-size"><h3>int-size</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The size in bytes of a c-sized int.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L241">view source</a></div></div><div class="public anchor" id="var-java-layout"><h3>java-layout</h3><div class="usage"><code>(java-layout type)</code></div><div class="doc"><div class="markdown"><p>Gets the Java class to an argument of this type for a method handle.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L70">view source</a></div></div><div class="public anchor" id="var-int-alignment"><h3>int-alignment</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The alignment in bytes of a c-sized int.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L265">view source</a></div></div><div class="public anchor" id="var-int-layout"><h3>int-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a c-sized int in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L213">view source</a></div></div><div class="public anchor" id="var-int-size"><h3>int-size</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The size in bytes of a c-sized int.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L241">view source</a></div></div><div class="public anchor" id="var-java-layout"><h3>java-layout</h3><div class="usage"><code>(java-layout type)</code></div><div class="doc"><div class="markdown"><p>Gets the Java class to an argument of this type for a method handle.</p>
 <p>If a type serializes to a primitive it returns return a Java primitive type. Otherwise, it returns <a href="null">MemorySegment</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L796">view source</a></div></div><div class="public anchor" id="var-java-prim-layout"><h3>java-prim-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Map of primitive type names to the Java types for a method handle.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L784">view source</a></div></div><div class="public anchor" id="var-little-endian"><h3>little-endian</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The little-endian <a href="null">ByteOrder</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L796">view source</a></div></div><div class="public anchor" id="var-java-prim-layout"><h3>java-prim-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Map of primitive type names to the Java types for a method handle.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L784">view source</a></div></div><div class="public anchor" id="var-little-endian"><h3>little-endian</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The little-endian <a href="null">ByteOrder</a>.</p>
 <p>See <a href="coffi.mem.html#var-big-endian">big-endian</a>, <a href="coffi.mem.html#var-native-endian">native-endian</a></p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L193">view source</a></div></div><div class="public anchor" id="var-long-alignment"><h3>long-alignment</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The alignment in bytes of a c-sized long.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L269">view source</a></div></div><div class="public anchor" id="var-long-layout"><h3>long-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a c-sized long in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L217">view source</a></div></div><div class="public anchor" id="var-long-size"><h3>long-size</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The size in bytes of a c-sized long.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L245">view source</a></div></div><div class="public anchor" id="var-native-endian"><h3>native-endian</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">ByteOrder</a> for the native endianness of the current hardware.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L193">view source</a></div></div><div class="public anchor" id="var-long-alignment"><h3>long-alignment</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The alignment in bytes of a c-sized long.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L269">view source</a></div></div><div class="public anchor" id="var-long-layout"><h3>long-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a c-sized long in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L217">view source</a></div></div><div class="public anchor" id="var-long-size"><h3>long-size</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The size in bytes of a c-sized long.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L245">view source</a></div></div><div class="public anchor" id="var-native-endian"><h3>native-endian</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">ByteOrder</a> for the native endianness of the current hardware.</p>
 <p>See <a href="coffi.mem.html#var-big-endian">big-endian</a>, <a href="coffi.mem.html#var-little-endian">little-endian</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L199">view source</a></div></div><div class="public anchor" id="var-null"><h3>null</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The NULL pointer object.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L199">view source</a></div></div><div class="public anchor" id="var-null"><h3>null</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The NULL pointer object.</p>
 <p>While this object is safe to pass to functions which serialize to a pointer, it’s generally encouraged to simply pass <code>nil</code>. This value primarily exists to make it easier to write custom types with a primitive pointer representation.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L111">view source</a></div></div><div class="public anchor" id="var-null.3F"><h3>null?</h3><div class="usage"><code>(null? addr)</code></div><div class="doc"><div class="markdown"><p>Checks if a memory address is null.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L119">view source</a></div></div><div class="public anchor" id="var-pointer-alignment"><h3>pointer-alignment</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The alignment in bytes of a c-sized pointer.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L281">view source</a></div></div><div class="public anchor" id="var-pointer-layout"><h3>pointer-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a native pointer in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L233">view source</a></div></div><div class="public anchor" id="var-pointer-size"><h3>pointer-size</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The size in bytes of a c-sized pointer.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L257">view source</a></div></div><div class="public anchor" id="var-primitive-type"><h3>primitive-type</h3><h4 class="type">multimethod</h4><div class="usage"></div><div class="doc"><div class="markdown"><p>Gets the primitive type that is used to pass as an argument for the <code>type</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L111">view source</a></div></div><div class="public anchor" id="var-null.3F"><h3>null?</h3><div class="usage"><code>(null? addr)</code></div><div class="doc"><div class="markdown"><p>Checks if a memory address is null.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L119">view source</a></div></div><div class="public anchor" id="var-pointer-alignment"><h3>pointer-alignment</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The alignment in bytes of a c-sized pointer.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L281">view source</a></div></div><div class="public anchor" id="var-pointer-layout"><h3>pointer-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a native pointer in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L233">view source</a></div></div><div class="public anchor" id="var-pointer-size"><h3>pointer-size</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The size in bytes of a c-sized pointer.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L257">view source</a></div></div><div class="public anchor" id="var-primitive-type"><h3>primitive-type</h3><h4 class="type">multimethod</h4><div class="usage"></div><div class="doc"><div class="markdown"><p>Gets the primitive type that is used to pass as an argument for the <code>type</code>.</p>
 <p>This is for objects which are passed to native functions as primitive types, but which need additional logic to be performed during serialization and deserialization.</p>
 <p>Implementations of this method should take into account that type arguments may not always be evaluated before passing to this function.</p>
 <p>Returns nil for any type which does not have a primitive representation.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L676">view source</a></div></div><div class="public anchor" id="var-primitive-types"><h3>primitive-types</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>A set of all primitive types.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L666">view source</a></div></div><div class="public anchor" id="var-primitive.3F"><h3>primitive?</h3><div class="usage"><code>(primitive? type)</code></div><div class="doc"><div class="markdown"><p>A predicate to determine if a given type is primitive.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L671">view source</a></div></div><div class="public anchor" id="var-read-address"><h3>read-address</h3><div class="usage"><code>(read-address segment)</code><code>(read-address segment offset)</code></div><div class="doc"><div class="markdown"><p>Reads an address from the <code>segment</code>, at an optional <code>offset</code>, wrapped in a <a href="null">MemorySegment</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L442">view source</a></div></div><div class="public anchor" id="var-read-byte"><h3>read-byte</h3><div class="usage"><code>(read-byte segment)</code><code>(read-byte segment offset)</code></div><div class="doc"><div class="markdown"><p>Reads a <a href="null">byte</a> from the <code>segment</code>, at an optional <code>offset</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L285">view source</a></div></div><div class="public anchor" id="var-read-char"><h3>read-char</h3><div class="usage"><code>(read-char segment)</code><code>(read-char segment offset)</code></div><div class="doc"><div class="markdown"><p>Reads a <a href="null">char</a> from the <code>segment</code>, at an optional <code>offset</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L376">view source</a></div></div><div class="public anchor" id="var-read-double"><h3>read-double</h3><div class="usage"><code>(read-double segment)</code><code>(read-double segment offset)</code><code>(read-double segment offset byte-order)</code></div><div class="doc"><div class="markdown"><p>Reads a <a href="null">double</a> from the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L676">view source</a></div></div><div class="public anchor" id="var-primitive-types"><h3>primitive-types</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>A set of all primitive types.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L666">view source</a></div></div><div class="public anchor" id="var-primitive.3F"><h3>primitive?</h3><div class="usage"><code>(primitive? type)</code></div><div class="doc"><div class="markdown"><p>A predicate to determine if a given type is primitive.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L671">view source</a></div></div><div class="public anchor" id="var-read-address"><h3>read-address</h3><div class="usage"><code>(read-address segment)</code><code>(read-address segment offset)</code></div><div class="doc"><div class="markdown"><p>Reads an address from the <code>segment</code>, at an optional <code>offset</code>, wrapped in a <a href="null">MemorySegment</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L442">view source</a></div></div><div class="public anchor" id="var-read-byte"><h3>read-byte</h3><div class="usage"><code>(read-byte segment)</code><code>(read-byte segment offset)</code></div><div class="doc"><div class="markdown"><p>Reads a <a href="null">byte</a> from the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L285">view source</a></div></div><div class="public anchor" id="var-read-char"><h3>read-char</h3><div class="usage"><code>(read-char segment)</code><code>(read-char segment offset)</code></div><div class="doc"><div class="markdown"><p>Reads a <a href="null">char</a> from the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L376">view source</a></div></div><div class="public anchor" id="var-read-double"><h3>read-double</h3><div class="usage"><code>(read-double segment)</code><code>(read-double segment offset)</code><code>(read-double segment offset byte-order)</code></div><div class="doc"><div class="markdown"><p>Reads a <a href="null">double</a> from the <code>segment</code>, at an optional <code>offset</code>.</p>
 <p>If <code>byte-order</code> is not provided, it defaults to <a href="coffi.mem.html#var-native-endian">native-endian</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L417">view source</a></div></div><div class="public anchor" id="var-read-float"><h3>read-float</h3><div class="usage"><code>(read-float segment)</code><code>(read-float segment offset)</code><code>(read-float segment offset byte-order)</code></div><div class="doc"><div class="markdown"><p>Reads a <a href="null">float</a> from the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L417">view source</a></div></div><div class="public anchor" id="var-read-float"><h3>read-float</h3><div class="usage"><code>(read-float segment)</code><code>(read-float segment offset)</code><code>(read-float segment offset byte-order)</code></div><div class="doc"><div class="markdown"><p>Reads a <a href="null">float</a> from the <code>segment</code>, at an optional <code>offset</code>.</p>
 <p>If <code>byte-order</code> is not provided, it defaults to <a href="coffi.mem.html#var-native-endian">native-endian</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L392">view source</a></div></div><div class="public anchor" id="var-read-int"><h3>read-int</h3><div class="usage"><code>(read-int segment)</code><code>(read-int segment offset)</code><code>(read-int segment offset byte-order)</code></div><div class="doc"><div class="markdown"><p>Reads a <a href="null">int</a> from the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L392">view source</a></div></div><div class="public anchor" id="var-read-int"><h3>read-int</h3><div class="usage"><code>(read-int segment)</code><code>(read-int segment offset)</code><code>(read-int segment offset byte-order)</code></div><div class="doc"><div class="markdown"><p>Reads a <a href="null">int</a> from the <code>segment</code>, at an optional <code>offset</code>.</p>
 <p>If <code>byte-order</code> is not provided, it defaults to <a href="coffi.mem.html#var-native-endian">native-endian</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L326">view source</a></div></div><div class="public anchor" id="var-read-long"><h3>read-long</h3><div class="usage"><code>(read-long segment)</code><code>(read-long segment offset)</code><code>(read-long segment offset byte-order)</code></div><div class="doc"><div class="markdown"><p>Reads a <a href="null">long</a> from the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L326">view source</a></div></div><div class="public anchor" id="var-read-long"><h3>read-long</h3><div class="usage"><code>(read-long segment)</code><code>(read-long segment offset)</code><code>(read-long segment offset byte-order)</code></div><div class="doc"><div class="markdown"><p>Reads a <a href="null">long</a> from the <code>segment</code>, at an optional <code>offset</code>.</p>
 <p>If <code>byte-order</code> is not provided, it defaults to <a href="coffi.mem.html#var-native-endian">native-endian</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L351">view source</a></div></div><div class="public anchor" id="var-read-short"><h3>read-short</h3><div class="usage"><code>(read-short segment)</code><code>(read-short segment offset)</code><code>(read-short segment offset byte-order)</code></div><div class="doc"><div class="markdown"><p>Reads a <a href="null">short</a> from the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L351">view source</a></div></div><div class="public anchor" id="var-read-short"><h3>read-short</h3><div class="usage"><code>(read-short segment)</code><code>(read-short segment offset)</code><code>(read-short segment offset byte-order)</code></div><div class="doc"><div class="markdown"><p>Reads a <a href="null">short</a> from the <code>segment</code>, at an optional <code>offset</code>.</p>
 <p>If <code>byte-order</code> is not provided, it defaults to <a href="coffi.mem.html#var-native-endian">native-endian</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L301">view source</a></div></div><div class="public anchor" id="var-reinterpret"><h3>reinterpret</h3><div class="usage"><code>(reinterpret segment size)</code><code>(reinterpret segment size arena)</code><code>(reinterpret segment size arena cleanup)</code></div><div class="doc"><div class="markdown"><p>Reinterprets the <code>segment</code> as having the passed <code>size</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L301">view source</a></div></div><div class="public anchor" id="var-reinterpret"><h3>reinterpret</h3><div class="usage"><code>(reinterpret segment size)</code><code>(reinterpret segment size arena)</code><code>(reinterpret segment size arena cleanup)</code></div><div class="doc"><div class="markdown"><p>Reinterprets the <code>segment</code> as having the passed <code>size</code>.</p>
 <p>If <code>arena</code> is passed, the scope of the <code>segment</code> is associated with the arena, as well as its access constraints. If <code>cleanup</code> is passed, it will be a 1-argument function of a fresh memory segment backed by the same memory as the returned segment which should perform any required cleanup operations. It will be called when the <code>arena</code> is closed.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L138">view source</a></div></div><div class="public anchor" id="var-seq-of"><h3>seq-of</h3><div class="usage"><code>(seq-of type segment)</code></div><div class="doc"><div class="markdown"><p>Constructs a lazy sequence of <code>type</code> elements deserialized from <code>segment</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L1104">view source</a></div></div><div class="public anchor" id="var-serialize"><h3>serialize</h3><div class="usage"><code>(serialize obj type)</code><code>(serialize obj type arena)</code></div><div class="doc"><div class="markdown"><p>Serializes an arbitrary type.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L138">view source</a></div></div><div class="public anchor" id="var-seq-of"><h3>seq-of</h3><div class="usage"><code>(seq-of type segment)</code></div><div class="doc"><div class="markdown"><p>Constructs a lazy sequence of <code>type</code> elements deserialized from <code>segment</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L1104">view source</a></div></div><div class="public anchor" id="var-serialize"><h3>serialize</h3><div class="usage"><code>(serialize obj type)</code><code>(serialize obj type arena)</code></div><div class="doc"><div class="markdown"><p>Serializes an arbitrary type.</p>
 <p>For types which have a primitive representation, this serializes into that representation. For types which do not, it allocates a new segment and serializes into that.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L954">view source</a></div></div><div class="public anchor" id="var-serialize*"><h3>serialize*</h3><h4 class="type">multimethod</h4><div class="usage"></div><div class="doc"><div class="markdown"><p>Constructs a serialized version of the <code>obj</code> and returns it.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L954">view source</a></div></div><div class="public anchor" id="var-serialize*"><h3>serialize*</h3><h4 class="type">multimethod</h4><div class="usage"></div><div class="doc"><div class="markdown"><p>Constructs a serialized version of the <code>obj</code> and returns it.</p>
 <p>Any new allocations made during the serialization should be tied to the given <code>arena</code>, except in extenuating circumstances.</p>
 <p>This method should only be implemented for types that serialize to primitives.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L825">view source</a></div></div><div class="public anchor" id="var-serialize-into"><h3>serialize-into</h3><h4 class="type">multimethod</h4><div class="usage"></div><div class="doc"><div class="markdown"><p>Writes a serialized version of the <code>obj</code> to the given <code>segment</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L825">view source</a></div></div><div class="public anchor" id="var-serialize-into"><h3>serialize-into</h3><h4 class="type">multimethod</h4><div class="usage"></div><div class="doc"><div class="markdown"><p>Writes a serialized version of the <code>obj</code> to the given <code>segment</code>.</p>
 <p>Any new allocations made during the serialization should be tied to the given <code>arena</code>, except in extenuating circumstances.</p>
 <p>This method should be implemented for any type which does not override <a href="coffi.mem.html#var-c-layout">c-layout</a>.</p>
 <p>For any other type, this will serialize it as <a href="coffi.mem.html#var-serialize*">serialize*</a> before writing the result value into the <code>segment</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L885">view source</a></div></div><div class="public anchor" id="var-shared-arena"><h3>shared-arena</h3><div class="usage"><code>(shared-arena)</code></div><div class="doc"><div class="markdown"><p>Constructs a new shared memory arena.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L885">view source</a></div></div><div class="public anchor" id="var-shared-arena"><h3>shared-arena</h3><div class="usage"><code>(shared-arena)</code></div><div class="doc"><div class="markdown"><p>Constructs a new shared memory arena.</p>
 <p>This arena can be shared across threads and memory allocated in it will only be cleaned up once any thread accessing the arena closes it.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L51">view source</a></div></div><div class="public anchor" id="var-short-alignment"><h3>short-alignment</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The alignment in bytes of a c-sized short.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L261">view source</a></div></div><div class="public anchor" id="var-short-layout"><h3>short-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a c-sized short in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L209">view source</a></div></div><div class="public anchor" id="var-short-size"><h3>short-size</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The size in bytes of a c-sized short.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L237">view source</a></div></div><div class="public anchor" id="var-size-of"><h3>size-of</h3><div class="usage"><code>(size-of type)</code></div><div class="doc"><div class="markdown"><p>The size in bytes of the given <code>type</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L804">view source</a></div></div><div class="public anchor" id="var-slice"><h3>slice</h3><div class="usage"><code>(slice segment offset)</code><code>(slice segment offset size)</code></div><div class="doc"><div class="markdown"><p>Get a slice over the <code>segment</code> with the given <code>offset</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L131">view source</a></div></div><div class="public anchor" id="var-slice-segments"><h3>slice-segments</h3><div class="usage"><code>(slice-segments segment size)</code></div><div class="doc"><div class="markdown"><p>Constructs a lazy seq of <code>size</code>-length memory segments, sliced from <code>segment</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L180">view source</a></div></div><div class="public anchor" id="var-write-address"><h3>write-address</h3><div class="usage"><code>(write-address segment value)</code><code>(write-address segment offset value)</code></div><div class="doc"><div class="markdown"><p>Writes the address of the <a href="null">MemorySegment</a> <code>value</code> to the <code>segment</code>, at an optional <code>offset</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L640">view source</a></div></div><div class="public anchor" id="var-write-byte"><h3>write-byte</h3><div class="usage"><code>(write-byte segment value)</code><code>(write-byte segment offset value)</code></div><div class="doc"><div class="markdown"><p>Writes a <a href="null">byte</a> to the <code>segment</code>, at an optional <code>offset</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L458">view source</a></div></div><div class="public anchor" id="var-write-char"><h3>write-char</h3><div class="usage"><code>(write-char segment value)</code><code>(write-char segment offset value)</code></div><div class="doc"><div class="markdown"><p>Writes a <a href="null">char</a> to the <code>segment</code>, at an optional <code>offset</code>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L560">view source</a></div></div><div class="public anchor" id="var-write-double"><h3>write-double</h3><div class="usage"><code>(write-double segment value)</code><code>(write-double segment offset value)</code><code>(write-double segment offset byte-order value)</code></div><div class="doc"><div class="markdown"><p>Writes a <a href="null">double</a> to the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L51">view source</a></div></div><div class="public anchor" id="var-short-alignment"><h3>short-alignment</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The alignment in bytes of a c-sized short.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L261">view source</a></div></div><div class="public anchor" id="var-short-layout"><h3>short-layout</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The <a href="null">MemoryLayout</a> for a c-sized short in <a href="coffi.mem.html#var-native-endian">native-endian</a> <a href="null">ByteOrder</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L209">view source</a></div></div><div class="public anchor" id="var-short-size"><h3>short-size</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The size in bytes of a c-sized short.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L237">view source</a></div></div><div class="public anchor" id="var-size-of"><h3>size-of</h3><div class="usage"><code>(size-of type)</code></div><div class="doc"><div class="markdown"><p>The size in bytes of the given <code>type</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L804">view source</a></div></div><div class="public anchor" id="var-slice"><h3>slice</h3><div class="usage"><code>(slice segment offset)</code><code>(slice segment offset size)</code></div><div class="doc"><div class="markdown"><p>Get a slice over the <code>segment</code> with the given <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L131">view source</a></div></div><div class="public anchor" id="var-slice-segments"><h3>slice-segments</h3><div class="usage"><code>(slice-segments segment size)</code></div><div class="doc"><div class="markdown"><p>Constructs a lazy seq of <code>size</code>-length memory segments, sliced from <code>segment</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L180">view source</a></div></div><div class="public anchor" id="var-write-address"><h3>write-address</h3><div class="usage"><code>(write-address segment value)</code><code>(write-address segment offset value)</code></div><div class="doc"><div class="markdown"><p>Writes the address of the <a href="null">MemorySegment</a> <code>value</code> to the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L640">view source</a></div></div><div class="public anchor" id="var-write-byte"><h3>write-byte</h3><div class="usage"><code>(write-byte segment value)</code><code>(write-byte segment offset value)</code></div><div class="doc"><div class="markdown"><p>Writes a <a href="null">byte</a> to the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L458">view source</a></div></div><div class="public anchor" id="var-write-char"><h3>write-char</h3><div class="usage"><code>(write-char segment value)</code><code>(write-char segment offset value)</code></div><div class="doc"><div class="markdown"><p>Writes a <a href="null">char</a> to the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L560">view source</a></div></div><div class="public anchor" id="var-write-double"><h3>write-double</h3><div class="usage"><code>(write-double segment value)</code><code>(write-double segment offset value)</code><code>(write-double segment offset byte-order value)</code></div><div class="doc"><div class="markdown"><p>Writes a <a href="null">double</a> to the <code>segment</code>, at an optional <code>offset</code>.</p>
 <p>If <code>byte-order</code> is not provided, it defaults to <a href="coffi.mem.html#var-native-endian">native-endian</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L612">view source</a></div></div><div class="public anchor" id="var-write-float"><h3>write-float</h3><div class="usage"><code>(write-float segment value)</code><code>(write-float segment offset value)</code><code>(write-float segment offset byte-order value)</code></div><div class="doc"><div class="markdown"><p>Writes a <a href="null">float</a> to the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L612">view source</a></div></div><div class="public anchor" id="var-write-float"><h3>write-float</h3><div class="usage"><code>(write-float segment value)</code><code>(write-float segment offset value)</code><code>(write-float segment offset byte-order value)</code></div><div class="doc"><div class="markdown"><p>Writes a <a href="null">float</a> to the <code>segment</code>, at an optional <code>offset</code>.</p>
 <p>If <code>byte-order</code> is not provided, it defaults to <a href="coffi.mem.html#var-native-endian">native-endian</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L584">view source</a></div></div><div class="public anchor" id="var-write-int"><h3>write-int</h3><div class="usage"><code>(write-int segment value)</code><code>(write-int segment offset value)</code><code>(write-int segment offset byte-order value)</code></div><div class="doc"><div class="markdown"><p>Writes a <a href="null">int</a> to the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L584">view source</a></div></div><div class="public anchor" id="var-write-int"><h3>write-int</h3><div class="usage"><code>(write-int segment value)</code><code>(write-int segment offset value)</code><code>(write-int segment offset byte-order value)</code></div><div class="doc"><div class="markdown"><p>Writes a <a href="null">int</a> to the <code>segment</code>, at an optional <code>offset</code>.</p>
 <p>If <code>byte-order</code> is not provided, it defaults to <a href="coffi.mem.html#var-native-endian">native-endian</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L504">view source</a></div></div><div class="public anchor" id="var-write-long"><h3>write-long</h3><div class="usage"><code>(write-long segment value)</code><code>(write-long segment offset value)</code><code>(write-long segment offset byte-order value)</code></div><div class="doc"><div class="markdown"><p>Writes a <a href="null">long</a> to the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L504">view source</a></div></div><div class="public anchor" id="var-write-long"><h3>write-long</h3><div class="usage"><code>(write-long segment value)</code><code>(write-long segment offset value)</code><code>(write-long segment offset byte-order value)</code></div><div class="doc"><div class="markdown"><p>Writes a <a href="null">long</a> to the <code>segment</code>, at an optional <code>offset</code>.</p>
 <p>If <code>byte-order</code> is not provided, it defaults to <a href="coffi.mem.html#var-native-endian">native-endian</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L532">view source</a></div></div><div class="public anchor" id="var-write-short"><h3>write-short</h3><div class="usage"><code>(write-short segment value)</code><code>(write-short segment offset value)</code><code>(write-short segment offset byte-order value)</code></div><div class="doc"><div class="markdown"><p>Writes a <a href="null">short</a> to the <code>segment</code>, at an optional <code>offset</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L532">view source</a></div></div><div class="public anchor" id="var-write-short"><h3>write-short</h3><div class="usage"><code>(write-short segment value)</code><code>(write-short segment offset value)</code><code>(write-short segment offset byte-order value)</code></div><div class="doc"><div class="markdown"><p>Writes a <a href="null">short</a> to the <code>segment</code>, at an optional <code>offset</code>.</p>
 <p>If <code>byte-order</code> is not provided, it defaults to <a href="coffi.mem.html#var-native-endian">native-endian</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/3c16e00fc1b7ca4d34d90c00003b7ea3785d9099/src/clj/coffi/mem.clj#L476">view source</a></div></div></div></body></html>
\ No newline at end of file
+</div></div><div class="src-link"><a href="https://github.com/IGJoshua/coffi/blob/58eaffdf543a3aa00436dafef2c65b247ad3f916/src/clj/coffi/mem.clj#L476">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/index.html b/docs/index.html
index 0009880..a753207 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>coffi v1.0.486</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li><li class="depth-1 "><a href="02-Memory-Management.html"><div class="inner"><span>Memory Management</span></div></a></li><li class="depth-1 "><a href="03-Builtin-Types.html"><div class="inner"><span>Built-in Types</span></div></a></li><li class="depth-1 "><a href="04-Custom-Types.html"><div class="inner"><span>Custom Types</span></div></a></li><li class="depth-1 "><a href="05-Low-Level-Wrappers.html"><div class="inner"><span>Low-Level Wrappers</span></div></a></li><li class="depth-1 "><a href="50-Data-Model.html"><div class="inner"><span>Data Model</span></div></a></li><li class="depth-1 "><a href="99-Benchmarks.html"><div class="inner"><span>Benchmarks</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></h1><div class="doc"><p>A Foreign Function Interface in Clojure for JDK 22+.</p></div><h2>Topics</h2><ul class="topics"><li><a href="01-Getting-Started.html">Getting Started</a></li><li><a href="02-Memory-Management.html">Memory Management</a></li><li><a href="03-Builtin-Types.html">Built-in Types</a></li><li><a href="04-Custom-Types.html">Custom Types</a></li><li><a href="05-Low-Level-Wrappers.html">Low-Level Wrappers</a></li><li><a href="50-Data-Model.html">Data Model</a></li><li><a href="99-Benchmarks.html">Benchmarks</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="coffi.ffi.html">coffi.ffi</a></h3><div class="doc"><div class="markdown"><p>Functions for creating handles to native functions and loading native libraries.</p>
+<html><head><meta charset="UTF-8" /><title>coffi v1.0.486</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="01-Getting-Started.html"><div class="inner"><span>Getting Started</span></div></a></li><li class="depth-1 "><a href="02-Memory-Management.html"><div class="inner"><span>Memory Management</span></div></a></li><li class="depth-1 "><a href="03-Builtin-Types.html"><div class="inner"><span>Built-in Types **WIP**</span></div></a></li><li class="depth-1 "><a href="04-Custom-Types.html"><div class="inner"><span>Custom Types</span></div></a></li><li class="depth-1 "><a href="05-Low-Level-Wrappers.html"><div class="inner"><span>Low-Level Wrappers</span></div></a></li><li class="depth-1 "><a href="50-Data-Model.html"><div class="inner"><span>Data Model</span></div></a></li><li class="depth-1 "><a href="99-Benchmarks.html"><div class="inner"><span>Benchmarks **OUTDATED**</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>coffi</span></div></div></li><li class="depth-2 branch"><a href="coffi.ffi.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>ffi</span></div></a></li><li class="depth-2 branch"><a href="coffi.layout.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>layout</span></div></a></li><li class="depth-2"><a href="coffi.mem.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>mem</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">coffi</span> <span class="project-version">v1.0.486</span></span></h1><div class="doc"><p>A Foreign Function Interface in Clojure for JDK 22+.</p></div><h2>Topics</h2><ul class="topics"><li><a href="01-Getting-Started.html">Getting Started</a></li><li><a href="02-Memory-Management.html">Memory Management</a></li><li><a href="03-Builtin-Types.html">Built-in Types **WIP**</a></li><li><a href="04-Custom-Types.html">Custom Types</a></li><li><a href="05-Low-Level-Wrappers.html">Low-Level Wrappers</a></li><li><a href="50-Data-Model.html">Data Model</a></li><li><a href="99-Benchmarks.html">Benchmarks **OUTDATED**</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="coffi.ffi.html">coffi.ffi</a></h3><div class="doc"><div class="markdown"><p>Functions for creating handles to native functions and loading native libraries.</p>
 </div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="coffi.ffi.html#var-cfn">cfn</a> </li><li> <a href="coffi.ffi.html#var-const">const</a> </li><li> <a href="coffi.ffi.html#var-defcfn">defcfn</a> </li><li> <a href="coffi.ffi.html#var-defconst">defconst</a> </li><li> <a href="coffi.ffi.html#var-defvar">defvar</a> </li><li> <a href="coffi.ffi.html#var-ensure-symbol">ensure-symbol</a> </li><li> <a href="coffi.ffi.html#var-find-symbol">find-symbol</a> </li><li> <a href="coffi.ffi.html#var-freset.21">freset!</a> </li><li> <a href="coffi.ffi.html#var-fswap.21">fswap!</a> </li><li> <a href="coffi.ffi.html#var-load-library">load-library</a> </li><li> <a href="coffi.ffi.html#var-load-system-library">load-system-library</a> </li><li> <a href="coffi.ffi.html#var-make-downcall">make-downcall</a> </li><li> <a href="coffi.ffi.html#var-make-serde-varargs-wrapper">make-serde-varargs-wrapper</a> </li><li> <a href="coffi.ffi.html#var-make-serde-wrapper">make-serde-wrapper</a> </li><li> <a href="coffi.ffi.html#var-make-varargs-factory">make-varargs-factory</a> </li><li> <a href="coffi.ffi.html#var-reify-libspec">reify-libspec</a> </li><li> <a href="coffi.ffi.html#var-reify-symbolspec">reify-symbolspec</a> </li><li> <a href="coffi.ffi.html#var-static-variable">static-variable</a> </li><li> <a href="coffi.ffi.html#var-static-variable-segment">static-variable-segment</a> </li><li> <a href="coffi.ffi.html#var-vacfn-factory">vacfn-factory</a> </li></ul></div></div><div class="namespace"><h3><a href="coffi.layout.html">coffi.layout</a></h3><div class="doc"><div class="markdown"><p>Functions for adjusting the layout of structs.</p>
 </div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="coffi.layout.html#var-with-c-layout">with-c-layout</a> </li></ul></div></div><div class="namespace"><h3><a href="coffi.mem.html">coffi.mem</a></h3><div class="doc"><div class="markdown"><p>Functions for managing native allocations, memory arenas, and (de)serialization.</p>
 </div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="coffi.mem.html#var-address-of">address-of</a> </li><li> <a href="coffi.mem.html#var-address.3F">address?</a> </li><li> <a href="coffi.mem.html#var-align-of">align-of</a> </li><li> <a href="coffi.mem.html#var-alloc">alloc</a> </li><li> <a href="coffi.mem.html#var-alloc-instance">alloc-instance</a> </li><li> <a href="coffi.mem.html#var-alloc-with">alloc-with</a> </li><li> <a href="coffi.mem.html#var-arena-allocator">arena-allocator</a> </li><li> <a href="coffi.mem.html#var-as-segment">as-segment</a> </li><li> <a href="coffi.mem.html#var-auto-arena">auto-arena</a> </li><li> <a href="coffi.mem.html#var-big-endian">big-endian</a> </li><li> <a href="coffi.mem.html#var-byte-layout">byte-layout</a> </li><li> <a href="coffi.mem.html#var-c-layout">c-layout</a> </li><li> <a href="coffi.mem.html#var-char-layout">char-layout</a> </li><li> <a href="coffi.mem.html#var-clone-segment">clone-segment</a> </li><li> <a href="coffi.mem.html#var-confined-arena">confined-arena</a> </li><li> <a href="coffi.mem.html#var-copy-segment">copy-segment</a> </li><li> <a href="coffi.mem.html#var-defalias">defalias</a> </li><li> <a href="coffi.mem.html#var-deserialize">deserialize</a> </li><li> <a href="coffi.mem.html#var-deserialize*">deserialize*</a> </li><li> <a href="coffi.mem.html#var-deserialize-from">deserialize-from</a> </li><li> <a href="coffi.mem.html#var-double-alignment">double-alignment</a> </li><li> <a href="coffi.mem.html#var-double-layout">double-layout</a> </li><li> <a href="coffi.mem.html#var-double-size">double-size</a> </li><li> <a href="coffi.mem.html#var-float-alignment">float-alignment</a> </li><li> <a href="coffi.mem.html#var-float-layout">float-layout</a> </li><li> <a href="coffi.mem.html#var-float-size">float-size</a> </li><li> <a href="coffi.mem.html#var-global-arena">global-arena</a> </li><li> <a href="coffi.mem.html#var-int-alignment">int-alignment</a> </li><li> <a href="coffi.mem.html#var-int-layout">int-layout</a> </li><li> <a href="coffi.mem.html#var-int-size">int-size</a> </li><li> <a href="coffi.mem.html#var-java-layout">java-layout</a> </li><li> <a href="coffi.mem.html#var-java-prim-layout">java-prim-layout</a> </li><li> <a href="coffi.mem.html#var-little-endian">little-endian</a> </li><li> <a href="coffi.mem.html#var-long-alignment">long-alignment</a> </li><li> <a href="coffi.mem.html#var-long-layout">long-layout</a> </li><li> <a href="coffi.mem.html#var-long-size">long-size</a> </li><li> <a href="coffi.mem.html#var-native-endian">native-endian</a> </li><li> <a href="coffi.mem.html#var-null">null</a> </li><li> <a href="coffi.mem.html#var-null.3F">null?</a> </li><li> <a href="coffi.mem.html#var-pointer-alignment">pointer-alignment</a> </li><li> <a href="coffi.mem.html#var-pointer-layout">pointer-layout</a> </li><li> <a href="coffi.mem.html#var-pointer-size">pointer-size</a> </li><li> <a href="coffi.mem.html#var-primitive-type">primitive-type</a> </li><li> <a href="coffi.mem.html#var-primitive-types">primitive-types</a> </li><li> <a href="coffi.mem.html#var-primitive.3F">primitive?</a> </li><li> <a href="coffi.mem.html#var-read-address">read-address</a> </li><li> <a href="coffi.mem.html#var-read-byte">read-byte</a> </li><li> <a href="coffi.mem.html#var-read-char">read-char</a> </li><li> <a href="coffi.mem.html#var-read-double">read-double</a> </li><li> <a href="coffi.mem.html#var-read-float">read-float</a> </li><li> <a href="coffi.mem.html#var-read-int">read-int</a> </li><li> <a href="coffi.mem.html#var-read-long">read-long</a> </li><li> <a href="coffi.mem.html#var-read-short">read-short</a> </li><li> <a href="coffi.mem.html#var-reinterpret">reinterpret</a> </li><li> <a href="coffi.mem.html#var-seq-of">seq-of</a> </li><li> <a href="coffi.mem.html#var-serialize">serialize</a> </li><li> <a href="coffi.mem.html#var-serialize*">serialize*</a> </li><li> <a href="coffi.mem.html#var-serialize-into">serialize-into</a> </li><li> <a href="coffi.mem.html#var-shared-arena">shared-arena</a> </li><li> <a href="coffi.mem.html#var-short-alignment">short-alignment</a> </li><li> <a href="coffi.mem.html#var-short-layout">short-layout</a> </li><li> <a href="coffi.mem.html#var-short-size">short-size</a> </li><li> <a href="coffi.mem.html#var-size-of">size-of</a> </li><li> <a href="coffi.mem.html#var-slice">slice</a> </li><li> <a href="coffi.mem.html#var-slice-segments">slice-segments</a> </li><li> <a href="coffi.mem.html#var-write-address">write-address</a> </li><li> <a href="coffi.mem.html#var-write-byte">write-byte</a> </li><li> <a href="coffi.mem.html#var-write-char">write-char</a> </li><li> <a href="coffi.mem.html#var-write-double">write-double</a> </li><li> <a href="coffi.mem.html#var-write-float">write-float</a> </li><li> <a href="coffi.mem.html#var-write-int">write-int</a> </li><li> <a href="coffi.mem.html#var-write-long">write-long</a> </li><li> <a href="coffi.mem.html#var-write-short">write-short</a> </li></ul></div></div></div></body></html>
\ No newline at end of file