package octez-l2-libs
Operations on C arrays.
type 'a t = 'a Ctypes.carray
val get : 'a t -> int -> 'a
get a n
returns the n
th element of the zero-indexed array a
. The semantics for non-scalar types are non-copying, as for (!@)
.
If you rebind the CArray
module to Array
then you can also use the syntax a.(n)
instead of Array.get a n
.
Raise Invalid_argument "index out of bounds"
if n
is outside of the range 0
to (CArray.length a - 1)
.
val set : 'a t -> int -> 'a -> unit
set a n v
overwrites the n
th element of the zero-indexed array a
with v
.
If you rebind the CArray
module to Array
then you can also use the a.(n) <- v
syntax instead of Array.set a n v
.
Raise Invalid_argument "index out of bounds"
if n
is outside of the range 0
to (CArray.length a - 1)
.
val unsafe_get : 'a t -> int -> 'a
unsafe_get a n
behaves like get a n
except that the check that n
between 0
and (CArray.length a - 1)
is not performed.
val unsafe_set : 'a t -> int -> 'a -> unit
unsafe_set a n v
behaves like set a n v
except that the check that n
between 0
and (CArray.length a - 1)
is not performed.
val of_string : string -> char t
of_string s
builds an array of the same length as s
plus one, and writes the elements of s
to the corresponding elements of the array with the null character '\0' as a last element.
val of_list : 'a Ctypes.typ -> 'a list -> 'a t
of_list t l
builds an array of type t
of the same length as l
, and writes the elements of l
to the corresponding elements of the array.
val to_list : 'a t -> 'a list
to_list a
builds a list of the same length as a
such that each element of the list is the result of reading the corresponding element of a
.
val iter : ('a -> unit) -> 'a t -> unit
iter f a
is analogous to Array.iter f a
: it applies f
in turn to all the elements of a
.
val map : 'b Ctypes.typ -> ('a -> 'b) -> 'a t -> 'b t
map t f a
is analogous to Array.map f a
: it creates a new array with element type t
whose elements are obtained by applying f
to the elements of a
.
val mapi : 'b Ctypes.typ -> (int -> 'a -> 'b) -> 'a t -> 'b t
mapi
behaves like Array.mapi
, except that it also passes the index of each element as the first argument to f
and the element itself as the second argument.
val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a
CArray.fold_left (@) x a
computes (((x @ a.(0)) @ a.(1)) ...) @ a.(n-1)
where n
is the length of the array a
.
val fold_right : ('b -> 'a -> 'a) -> 'b t -> 'a -> 'a
CArray.fold_right f a x
computes a.(0) @ (a.(1) @ ( ... (a.(n-1) @ x) ...))
where n
is the length of the array a
.
val length : 'a t -> int
Return the number of elements of the given array.
val start : 'a t -> 'a Ctypes.ptr
Return the address of the first element of the given array.
val from_ptr : 'a Ctypes.ptr -> int -> 'a t
from_ptr p n
creates an n
-length array reference to the memory at address p
.
val make :
?finalise:('a t -> unit) ->
'a Ctypes.typ ->
?initial:'a ->
int ->
'a t
make t n
creates an n
-length array of type t
. If the optional argument ?initial
is supplied, it indicates a value that should be used to initialise every element of the array. The argument ?finalise
, if present, will be called just before the memory is freed.
sub a ~pos ~length
creates a fresh array of length length
containing the elements a.(pos)
to a.(pos + length - 1)
of a
.
Raise Invalid_argument "CArray.sub"
if pos
and length
do not designate a valid subarray of a
.
val element_type : 'a t -> 'a Ctypes.typ
Retrieve the element type of an array.