Up

Module type S

Signature

include File_descr_watcher_intf.S
type t

A file-descr-watcher is essentially a map from File_descr.t to bool Read_write.t, which defines the set of file descriptors being watched, and for each file descriptor, whether it is being watched for read, write, or both. If a file descriptor is not being watched for either, it is not in the map.

val sexp_of_t : t -> Sexplib.Sexp.t
include Core.Std.Invariant.S with type t := t
type t
val invariant : t Invariant_intf.inv
type 'a additional_create_args

additional_create_args abstracts over the additional arguments to different file-descr-watcher's create function.

val create : (num_file_descrs:int -> handle_fd_read_ready:(Import.File_descr.t -> unit) -> handle_fd_write_ready:(Import.File_descr.t -> unit) -> t) additional_create_args

create ~num_file_descrs creates a new file-descr-watcher that is able to watch file descriptors in 

 [0, num_file_descrs)

.

val set : t -> Import.File_descr.t -> bool Read_write.t -> unit

set alters the map of file descriptors being watched. It will take effect on the next call to thread_safe_check. Calling set fd with { read = false, write = false } removes fd from the map.

val iter : t -> f:(Import.File_descr.t -> Read_write.Key.t -> unit) -> unit

iter t ~f iterates over every file descriptor in the map, apply f to it once for each of {`Read,`Write} that it is being watched for.

module Pre : sig .. end
pre_check t does whatever non-thread-safe work is necessary to prepare for the system call that checks file descriptors being ready for read or write.
val pre_check : t -> Pre.t
module Check_result : sig .. end
thread_safe_check t pre timeout span_or_unit checks the file descriptors for their status and returns when at least one is available, or the timeout, span_or_unit passes.
val thread_safe_check : t -> Pre.t -> 'a File_descr_watcher_intf.Timeout.t -> 'a -> Check_result.t
val post_check : t -> Check_result.t -> unit

post_check t check_result calls the handle_fd* functions supplied to create:

1. for each file descriptor that is ready to be written to, then 2. for each file descriptor that is ready to be read from.

We handle writes before reads so that we get all the writes started going to the external world before we process all the reads. This will nicely batch together all the output based on the reads for the next writes.

It is guaranteed that it calls handle_fd_read* only on an fd that is watched for read as per set, and handle_fd_write* only on an fd that is watched for write as per set.

val reset_in_forked_process : t -> unit
val watcher : t