Module Capnp.Array
Contents
Instructions: Use this module in your project
In the IDE (CLion, Visual Studio Code, Xcode, etc.) you use for your DkSDK project:
Add the following to your project's
dependencies/CMakeLists.txt
:DkSDKProject_DeclareAvailable(capnp CONSTRAINT "= 3.5.0" FINDLIBS capnp capnp.unix) DkSDKProject_MakeAvailable(capnp)
Add the
Findlib::capnp
library to any desired targets insrc/*/CMakeLists.txt
:target_link_libraries(YourPackage_YourLibraryName # ... existing libraries, if any ... Findlib::capnp)
Click your IDE's
Build
button
Not using DkSDK?
FIRST, do one or all of the following:
Run:
opam install capnp.3.5.0
Edit your
dune-project
and add:(package (name YourExistingPackage) (depends ; ... existing dependenices ... (capnp (>= 3.5.0))))
Then run:
dune build *.opam # if this fails, run: dune build
Edit your
<package>.opam
file and add:depends: [ # ... existing dependencies ... "capnp" {>= "3.5.0"} ]
Then run:
opam install . --deps-only
FINALLY, add the capnp
library to any desired (library)
and/or (executable)
targets in your **/dune
files:
(library
(name YourLibrary)
; ... existing library options ...
(libraries
; ... existing libraries ...
capnp))
(executable
(name YourExecutable)
; ... existing executable options ...
(libraries
; ... existing libraries ...
capnp))
type
ro`` =
Message.ro
type
rw`` =
Message.rw
type
``('cap, 'a, 'arr) t
The array type. The first type parameter represents the read and/or
write capability, i.e. ro
or rw
. The second type parameter is the
type of elements stored in the array. The third type parameter describes
the underlying storage for the array.
val
length : ``(
'cap
,
'a
,
'arr
)``
t
->
int
Return the length (number of elements) of the given array.
val
get : ``(
'cap
,
'a
,
'arr
)``
t
->
``int
->
'a
get a n
returns element number n
of array a
, indexed from 0.
-
raises Invalid_argument
"index out of bounds" if
n
is outside the range 0 tolength a
- 1.
set a n x
places value x
in element number n
of array a
, indexed
from 0.
-
raises Invalid_argument
"index out of bounds" if
n
is outside the range 0 tolength a
- 1.
init a n
destroys the content of array a
, replacing it with
newly-allocated array storage of length n
. The new array elements are
initialized to the empty state (zero for primitives and default values
for structs).
val
mem : ``?equal:``(
'a
->
'a
->
bool)``
->
``(
'cap
,
'a
,
'arr
)``
t
->
'a
->
bool
mem ~equal a x
tests whether element x
is present in array a
,
using the provided equality function. If the equality function is not
provided, polymorphic compare is used.
val
is_empty : ``(
'cap
,
'a
,
'arr
)``
t
->
bool
is_empty a
returns true
if array a
has length 0.
val
iter : ``(
'cap
,
'a
,
'arr
)``
t
->
``f:``(
'a
->
unit)``
->
unit
iter a ~f
applies f
to each element of array a
, in order.
val
iteri : ``(
'cap
,
'a
,
'arr
)``
t
->
``f:``(``int
->
'a
->
unit)``
->
unit
iteri a ~f
behaves as iter
, but also passes the index of each
element as an argument to f
.
val
fold : ``(
'cap
,
'a
,
'arr
)``
t
->
``init:
'acc
->
``f:``(
'acc
->
'a
->
'acc
)``
->
'acc
fold a ~init ~f
returns f (... f (f (f init e1) e2) e3 ...) en
,
where e1..en
are the elements of a
.
val
fold_right : ``(
'cap
,
'a
,
'arr
)``
t
->
``f:``(
'a
->
'acc
->
'acc
)``
->
``init:
'acc
->
'acc
fold_right a ~f ~init
returns f e1 (f e2 (... (f en init) ...))
.
val
foldi : ``(
'cap
,
'a
,
'arr
)``
t
->
``init:
'acc
->
``f:``(``int
->
'acc
->
'a
->
'acc
)``
->
'acc
foldi a ~init f
behaves as fold
, but also passes the index of each
element as an argument to f
.
val
foldi_right : ``(
'cap
,
'a
,
'arr
)``
t
->
``f:``(``int
->
'a
->
'acc
->
'acc
)``
->
``init:
'acc
->
'acc
foldi_right a ~f ~init
behaves as foldi
, but also passes the index
of each element as an argument to f
.
val
exists : ``(
'cap
,
'a
,
'arr
)``
t
->
``f:``(
'a
->
bool)``
->
bool
exists a ~f
returns true
if and only if there exists an element for
which the provided function evaluates to true
. This is a
short-circuiting operation.
val
forall : ``(
'cap
,
'a
,
'arr
)``
t
->
``f:``(
'a
->
bool)``
->
bool
forall a ~f
returns true
if and only if the provided function
evalues to true
for all elements. This is a short-circuiting
operation.
val
count : ``(
'cap
,
'a
,
'arr
)``
t
->
``f:``(
'a
->
bool)``
->
int
count a ~f
returns the number of elements for which the provided
function evaluates to true
.
val
find : ``(
'cap
,
'a
,
'arr
)``
t
->
``f:``(
'a
->
bool)``
->
'a
option
find a ~f
returns as an option
the first element for which f
evaluates to true
.
val
find_map : ``(
'cap
,
'a
,
'arr
)``
t
->
``f:``(
'a
->
'b
option``)``
->
'b
option
find_map a ~f
returns the first evaluation of f
that returns Some
,
and returns None
if there is no such element.
val
to_list : ``(
'cap
,
'a
,
'arr
)``
t
->
'a
list
to_list a
returns an OCaml list containing all the elements of a
, in
order.
val
to_array : ``(
'cap
,
'a
,
'arr
)``
t
->
'a
array
to_array a
returns an OCaml array containing all the elements of a
,
in order.
set_list a lst
resizes array a
and sets its content of list lst
.
set_array a arr
resizes array a
and sets its content of OCaml array
arr
val
map_array : ``(
'cap
,
'a
,
'arr
)``
t
->
``f:``(
'a
->
'b
)``
->
'b
array
map_array a ~f
returns | f e1; f e2; ... f en |
, where e1..en
are
the elements of a
.
val
map_list : ``(
'cap
,
'a
,
'arr
)``
t
->
``f:``(
'a
->
'b
)``
->
'b
list
map_list a ~f
returns f e1; f e2; ... f en
, where e1..en
are the
elements of a
. The elements are evaluated in reverse order.