Previous  Up  Next

Module Std_kernel.Flat_queue

module Flat_queue: Flat_queue
module Slots: Tuple_type.Slots 
module Slot: Tuple_type.Slot 
type 'slots t
The type of a flat queue. 'slots will look like ('a1, ..., 'an) Slots.tn, and the queue holds flat tuples of type 'a1 * ... * 'an.
include Invariant.S1
val create : ?capacity:int -> ('a, 'b) Slots.t -> ('a, 'b) Slots.t t
create ?capacity slots creates an empty queue with capacity at least the supplied capacity. It is an error if capacity <= 0.
val capacity : 'a t -> int
capacity t returns the length of the array backing t. Enqueueing values will not cause the array to grow as long as length t <= capacity t. A queue at capacity will automatically increase capacity when enqueueing. The capacity never decreases automatically; one can only decrease capacity via set_capacity.
val set_capacity : 'a t -> int -> unit
set_capacity t capacity sets the length of the array backing t to as small as value as possible that is not less than max capacity (length t). To shrink as much as possible, do set_capacity t 0.
val length : 'a t -> int
val is_empty : 'a t -> bool
val get : ('b, 'v) Slots.t t -> int -> ('v, 'a) Slot.t -> 'a
These functions get and set individual slots of flat tuple i in queue t.

It is required that 0 <= i < length t.

val unsafe_get : ('b, 'v) Slots.t t -> int -> ('v, 'a) Slot.t -> 'a
val set : ('b, 'v) Slots.t t -> int -> ('v, 'a) Slot.t -> 'a -> unit
val unsafe_set : ('b, 'v) Slots.t t -> int -> ('v, 'a) Slot.t -> 'a -> unit
val drop_front : ?n:int -> 'a t -> unit
drop_front ?n t drops the the first n elements of t. It raises if n < 0 || n > length t.

Flat_queue does not have dequeue or dequeue_exn because the expected usage is to use get t 0 Slot.tj to access the front of the queue, and then to use drop_front to remove it. This usage avoids ever allocating an ordinary OCaml tuple.

val clear : 'a t -> unit
clear t removes all elements from t.
val enqueue1 : 'a0 Slots.t1 t -> 'a0 -> unit
There is an enqueueN function for each possible arity of a flat queue.
val enqueue2 : ('a0, 'a1) Slots.t2 t -> 'a0 -> 'a1 -> unit
val enqueue3 : ('a0, 'a1, 'a2) Slots.t3 t -> 'a0 -> 'a1 -> 'a2 -> unit
val enqueue4 : ('a0, 'a1, 'a2, 'a3) Slots.t4 t ->
       'a0 -> 'a1 -> 'a2 -> 'a3 -> unit
val enqueue5 : ('a0, 'a1, 'a2, 'a3, 'a4) Slots.t5 t ->
       'a0 -> 'a1 -> 'a2 -> 'a3 -> 'a4 -> unit
val enqueue6 : ('a0, 'a1, 'a2, 'a3, 'a4, 'a5) Slots.t6 t ->
       'a0 -> 'a1 -> 'a2 -> 'a3 -> 'a4 -> 'a5 -> unit
val enqueue7 : ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6) Slots.t7 t ->
       'a0 -> 'a1 -> 'a2 -> 'a3 -> 'a4 -> 'a5 -> 'a6 -> unit
val enqueue8 : ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7) Slots.t8 t ->
       'a0 -> 'a1 -> 'a2 -> 'a3 -> 'a4 -> 'a5 -> 'a6 -> 'a7 -> unit
val enqueue9 : ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8) Slots.t9 t ->
       'a0 -> 'a1 -> 'a2 -> 'a3 -> 'a4 -> 'a5 -> 'a6 -> 'a7 -> 'a8 -> unit

The functions below deal with Flat-array tuples as ordinary OCaml tuples. These are intended for convenience but not for performance-critical code, due to the tuple allocation.
val get_all_slots : ('tuple, 'a) Slots.t t -> int -> 'tuple
get_all_slots t i allocates a new ordinary OCaml tuple whose components are equal to the slots of the flat tuple at index i of t. This is esentially an allocation plus a blit from t to the newly allocated tuple.

set_all_slots t i tuple sets all slots of the flat tuple at index i of t to their corresponding components of tuple. This is essentially a blit from tuple to t.

It is required that 0 <= i < length t.

val set_all_slots : ('tuple, 'a) Slots.t t -> int -> 'tuple -> unit
val fold : ('tuple, 'b) Slots.t t -> init:'a -> f:('a -> 'tuple -> 'a) -> 'a
In iter t ~f and fold t ~init ~f, if f mutates t, then the iteration will raise.
val iter : ('tuple, 'a) Slots.t t -> f:('tuple -> unit) -> unit
val sexp_of_t : ('slots -> Sexplib.Sexp.t) -> 'slots t -> Sexplib.Sexp.t

create ?capacity slots creates an empty queue with capacity at least the supplied capacity. It is an error if capacity <= 0.

capacity t returns the length of the array backing t. Enqueueing values will not cause the array to grow as long as length t <= capacity t. A queue at capacity will automatically increase capacity when enqueueing. The capacity never decreases automatically; one can only decrease capacity via set_capacity.

set_capacity t capacity sets the length of the array backing t to as small as value as possible that is not less than max capacity (length t). To shrink as much as possible, do set_capacity t 0.

These functions get and set individual slots of flat tuple i in queue t.

It is required that 0 <= i < length t.

drop_front ?n t drops the the first n elements of t. It raises if n < 0 || n > length t.

Flat_queue does not have dequeue or dequeue_exn because the expected usage is to use get t 0 Slot.tj to access the front of the queue, and then to use drop_front to remove it. This usage avoids ever allocating an ordinary OCaml tuple.

default is 1.

clear t removes all elements from t.

There is an enqueueN function for each possible arity of a flat queue.

The functions below deal with Flat-array tuples as ordinary OCaml tuples. These are intended for convenience but not for performance-critical code, due to the tuple allocation.

get_all_slots t i allocates a new ordinary OCaml tuple whose components are equal to the slots of the flat tuple at index i of t. This is esentially an allocation plus a blit from t to the newly allocated tuple.

set_all_slots t i tuple sets all slots of the flat tuple at index i of t to their corresponding components of tuple. This is essentially a blit from tuple to t.

It is required that 0 <= i < length t.

In iter t ~f and fold t ~init ~f, if f mutates t, then the iteration will raise.