A signal manager keeps track of a set of signals to be managed and the signal handlers for them. When a signal manager is managing a signal, it installs its own OCaml handler for that signal that records delivery of the signal. It then later, upon request, will deliver the signal to all its handlers.

Once a signal manager starts managing a signal, it never stops.

type t
include Core.Std.Invariant.S with type t := t
val create : thread_safe_notify_signal_delivered:(unit -> unit) -> t
create creates and returns a signal manager t. Whenever a signal that t is managing is delivered, it will call thread_safe_notify_signal_delivered from within the OCaml signal handler. Therefore thread_safe_notify_signal_delivered must be thread safe.
val manage : t -> Core.Std.Signal.t -> unit
manage t signal causes t to manage signal, thus overriding default_sys_behavior for that signal, and any other OCaml handler for that signal.
val is_managing : t -> Core.Std.Signal.t -> bool
is_managing t signal returns true iff manage t signal has been called
type handler
install_handler t signals f causes t to manage the handling of signals, and registers f to run on every signal in signals that is delivered. It is an error if f ever raises when it is called.
val install_handler : t -> Core.Std.Signal.t list -> (Core.Std.Signal.t -> unit) -> handler
val remove_handler : t -> handler -> unit
remove_handler handler causes the particular handler to no longer handle the signals it was registered to handle. The signal manager continues to manage those signals, i.e. the OCaml signal handler remains installed, whether or not they still have handlers.
val handle_delivered : t -> unit
handle_delivered t runs all signal handlers on the signals that have been delivered but not yet handled.
val sexp_of_t : t -> Sexplib.Sexp.t