module StringMap : sig
type key = String.t
- type 'a t = 'a Map.Make(String).t
+ type 'a t
val empty : 'a t
val is_empty : 'a t -> bool
val mem : key -> 'a t -> bool
end
(** A map from string to any type. *)
+module IntMap : sig
+ type key = int
+ type 'a t
+ val empty : 'a t
+ val is_empty : 'a t -> bool
+ val mem : key -> 'a t -> bool
+ val add : key -> 'a -> 'a t -> 'a t
+ (*val singleton : key -> 'a -> 'a t*)
+ val remove : key -> 'a t -> 'a t
+ (*val merge :
+ (key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t*)
+ val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
+ val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
+ val iter : (key -> 'a -> unit) -> 'a t -> unit
+ val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
+ (*val for_all : (key -> 'a -> bool) -> 'a t -> bool
+ val exists : (key -> 'a -> bool) -> 'a t -> bool
+ val filter : (key -> 'a -> bool) -> 'a t -> 'a t
+ val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
+ val cardinal : 'a t -> int
+ val bindings : 'a t -> (key * 'a) list
+ val min_binding : 'a t -> key * 'a
+ val max_binding : 'a t -> key * 'a
+ val choose : 'a t -> key * 'a
+ val split : key -> 'a t -> 'a t * 'a option * 'a t*)
+ val find : key -> 'a t -> 'a
+ val map : ('a -> 'b) -> 'a t -> 'b t
+ val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
+ val keys : 'a t -> key list
+ val values : 'a t -> 'a list
+end
+(** A map from int to any type. *)
+
module StringSet : sig
type elt = String.t
type t = Set.Make(String).t
end
(** A set of strings. *)
+val (//) : string -> string -> string
+(** [dir // file] concatenates directory and file. *)
+
+val filter_map : ('a -> 'b option) -> 'a list -> 'b list
+(** Filter + map. *)
+
type whenexpr =
| Expr_bool of bool (** A boolean constant. *)
| Expr_str of string (** A string constant. *)
| Expr_var of string (** A variable name. *)
| Expr_and of whenexpr * whenexpr (** && *)
| Expr_or of whenexpr * whenexpr (** || *)
+ | Expr_lt of whenexpr * whenexpr (** < *)
+ | Expr_le of whenexpr * whenexpr (** <= *)
| Expr_eq of whenexpr * whenexpr (** == *)
- | Expr_not of whenexpr (** ! *)
+ | Expr_ge of whenexpr * whenexpr (** >= *)
+ | Expr_gt of whenexpr * whenexpr (** > *)
+ | Expr_not of whenexpr (** boolean not *)
+ | Expr_add of whenexpr * whenexpr (** arithmetic addition or string cat *)
+ | Expr_sub of whenexpr * whenexpr (** arithmetic subtraction *)
+ | Expr_mul of whenexpr * whenexpr (** arithmetic multiplication *)
+ | Expr_div of whenexpr * whenexpr (** arithmetic division *)
+ | Expr_mod of whenexpr * whenexpr (** arithmetic modulo *)
| Expr_changes of string (** changes var *)
+ | Expr_increases of string (** increases var *)
+ | Expr_decreases of string (** decreases var *)
+ | Expr_prev of string (** prev var *)
(** Internal type used to represent 'when' expressions. *)
type periodexpr =
| T_float of float
(** Typed variable (see also [whenproto.x]) *)
+val string_of_variable : variable -> string
+
val variable_of_rpc : Whenproto_aux.variable -> variable
val rpc_of_variable : variable -> Whenproto_aux.variable
possibly-updated [job] structure.
This is a no-op for 'every' jobs. *)
+
+val next_periodexpr : float -> periodexpr -> float
+(** [next_periodexpr t period] returns the earliest event of [period]
+ strictly after time [t].
+
+ Visualising periods as repeated events on a timeline, this
+ returns [t']:
+
+ {v
+ events: ---+---------+---------+---------+---------+---------+-----
+ times: t t'
+ }
+
+ Note that [periodexpr] events are not necessarily regular.
+ eg. The start of a month is not a fixed number of seconds
+ after the start of the previous month. 'Epoch' refers
+ to the Unix Epoch (ie. 1970-01-01 00:00:00 UTC).
+
+ If [period = Every_seconds i] then events are when
+ [t' mod i == 0] when t' is the number of seconds since
+ the Epoch. This returns the next t' > t.
+
+ If [period = Every_days i] then events happen at
+ midnight UTC every [i] days since the Epoch.
+ This returns the next midnight > t.
+
+ If [period = Every_months i] then events happen at
+ midnight UTC on the 1st day of the month every [i] months
+ since the Epoch. This returns midnight on the
+ 1st day of the next month > t.
+
+ If [period = Every_years i] then events happen at
+ midnight UTC on the 1st day of the year when
+ [(y - 1970) mod i == 0]. This returns midnight on the
+ 1st day of the next year > t. *)