Module Synchronous_time_source.Event
val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
val at : [> Core_kernel.read ] T1.t -> Async_kernel__.Import.Time_ns.t -> callback -> t
These are like the corresponding
run_*
functions, except they return an event that one can laterabort
.
val after : [> Core_kernel.read ] T1.t -> Async_kernel__.Import.Time_ns.Span.t -> callback -> t
val at_intervals : [> Core_kernel.read ] T1.t -> Async_kernel__.Import.Time_ns.Span.t -> callback -> t
module Abort_result : sig ... end
val abort : [> Core_kernel.read ] T1.t -> t -> Abort_result.t
abort t
aborts the eventt
, if possible, and returnsOk
if the event was aborted, or the reason it could not be aborted.abort
returnsCurrently_happening
iff it is called on an event while running that event's callback.
val abort_exn : [> Core_kernel.read ] T1.t -> t -> unit
val abort_if_possible : [> Core_kernel.read ] T1.t -> t -> unit
val create : [> Core_kernel.read ] T1.t -> callback -> t
create timesource callback
creates an event that is not scheduled intimesource
's timing wheel but is available to be scheduled usingschedule_at
andschedule_after
.
val schedule_at : [> Core_kernel.read ] T1.t -> t -> Async_kernel__.Import.Time_ns.t -> unit Core_kernel.Or_error.t
schedule_at timesource t time
schedulest
to fire attime
.schedule_at
returnsError
ift
is currently scheduled to run.
val schedule_after : [> Core_kernel.read ] T1.t -> t -> Async_kernel__.Import.Time_ns.Span.t -> unit Core_kernel.Or_error.t
val schedule_at_intervals : [> Core_kernel.read ] T1.t -> t -> Async_kernel__.Import.Time_ns.Span.t -> unit Core_kernel.Or_error.t
module Reschedule_result : sig ... end
val reschedule_at : [> Core_kernel.read ] T1.t -> t -> Async_kernel__.Import.Time_ns.t -> Reschedule_result.t
reschedule_at timesource t time
attempts to updatet
to next fire attime
. This returnsOk
for events that are unscheduled, or scheduled but not yet fired. If the event is in the process of firing or being aborted,reschedule_at
does not succeed. For periodic events,reschedule
updates the next time to fire, and leave the interval unchanged. Events rescheduled to a past time will fire at the next advance oftimesource
.
val reschedule_after : [> Core_kernel.read ] T1.t -> t -> Async_kernel__.Import.Time_ns.Span.t -> Reschedule_result.t