package core_unix

You can search for identifiers within the package.

in-package search v0.2.0

core_unix
- Core_unix
core_unix.bigbuffer_blocking
- Core_unix_bigbuffer_blocking
core_unix.bigstring_unix
- Core_unix_bigstring_unix
core_unix.command_unix
- Command_unix
core_unix.core_thread
- Core_thread
core_unix.daemon
- Core_unix_daemon
core_unix.date_unix
- Date_unix
core_unix.error_checking_mutex
- Core_unix_error_checking_mutex
core_unix.filename_unix
- Filename_unix
core_unix.interval_lib
- Interval_lib
core_unix.iobuf_unix
- Core_unix_iobuf_unix
core_unix.linux_ext
- Core_unix_linux_ext
core_unix.lock_file_blocking
- Core_unix_lock_file_blocking
core_unix.nano_mutex
- Core_unix_nano_mutex
core_unix.process_env
- Core_unix_process_env
core_unix.signal_unix
- Signal_unix
core_unix.squeue
- Core_unix_squeue
core_unix.sys_unix
- Sys_unix
core_unix.syslog
- Core_unix_syslog
core_unix.time_interface
- Time_interface
core_unix.time_ns_unix
- Time_ns_unix
core_unix.time_stamp_counter
- Core_unix_time_stamp_counter
core_unix.time_unix
- Time_unix
core_unix.uuid_unix
- Core_unix_uuid_unix

Legend:
Library
Module
Module type
Parameter
Class
Class type

include module type of struct include Squeue end

type 'a t = 'a Squeue.t

val sexp_of_t : 
  ('a -> Ppx_sexp_conv_lib.Sexp.t) ->
  'a t ->
  Ppx_sexp_conv_lib.Sexp.t

val create : int -> 'a t

create maxsize returns a synchronized queue bounded to have no more than maxsize elements.

val push : 'a t -> 'a -> unit

Blocks until there's room on the queue, then pushes.

val push_uncond : 'a t -> 'a -> unit

Does not block, may grow the queue past maxsize.

val push_or_drop : 'a t -> 'a -> bool

Pushes an event on the queue if the queue is less than maxsize, otherwise drops it. Returns true if the push was successful

val length : 'a t -> int

Returns the number of elements in the queue.

val pop : 'a t -> 'a

Pops an element off the queue, blocking until something is available

val lpop : 'a t -> 'a * int

Returns the element popped and the length of the queue this element was popped.

val transfer_queue_in : 'a t -> 'a Core_kernel.Linked_queue.t -> unit

Transfers all the elements from an ordinary queue into the squeue. Blocks until there's room on the queue, then pushes. May grow queue past maxsize.

val transfer_queue_in_uncond : 'a t -> 'a Core_kernel.Linked_queue.t -> unit

val transfer_queue : 'a t -> 'a Core_kernel.Linked_queue.t -> unit

Transfers all elements from the squeue to an ordinary queue. The elements remain in order. Waits until at least one element can be transferred.

val transfer_queue_nowait : 'a t -> 'a Core_kernel.Linked_queue.t -> unit

Transfers all elements from the squeue to an ordinary queue. The elements remain in order. Does not wait for elements to arrive.

val clear : 'a t -> unit

Clears the queue

val wait_not_empty : 'a t -> unit

wait_not_empty sq waits for something to be available. This is useful if you want to wait, but not take something out. This function is not useful in most cases, but in some complex cases it is essential. For example, if you need to take another lock before you remove something from the queue for processing, you might want to try to take that other lock, and if it fails do something else.

This function is not dangerous, there is just one thing you have to remember if you use it: Just because this function returns doesn't mean that pop will succeed; someone might have gotten there first, so you have to use transfer_queue_nowait if you don't want to block.