X-Git-Url: http://git.annexia.org/?p=whenjobs.git;a=blobdiff_plain;f=lib%2Fwhenutils.mli;h=ef3f5918e1451cc61c5b7c8f3ae8d99fe4e3aa38;hp=2d5bbfae20ba2e02cc7231b9ccb2e3912bb50dee;hb=HEAD;hpb=0f58f891d531defd1fa923dd2da93678c9c6f35b

diff --git a/lib/whenutils.mli b/lib/whenutils.mli
index 2d5bbfa..ef3f591 100644
--- a/lib/whenutils.mli
+++ b/lib/whenutils.mli
@@ -20,7 +20,7 @@
 
 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
@@ -51,6 +51,72 @@ module StringMap : sig
 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 BigIntMap : sig
+  type key = Big_int.big_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 big_int to any type. *)
+
 module StringSet : sig
   type elt = String.t
   type t = Set.Make(String).t
@@ -81,123 +147,23 @@ module StringSet : sig
 end
 (** A set of strings. *)
 
-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_int of Big_int.big_int         (** An integer constant. *)
-  | Expr_float of float                 (** A float constant. *)
-  | Expr_var of string                  (** A variable name. *)
-  | Expr_and of whenexpr * whenexpr     (** && *)
-  | Expr_or of whenexpr * whenexpr      (** || *)
-  | Expr_eq of whenexpr * whenexpr      (** == *)
-  | Expr_not of whenexpr                (** ! *)
-  | Expr_changes of string              (** changes var *)
-(** Internal type used to represent 'when' expressions. *)
-
-type periodexpr =
-  | Every_seconds of int
-  | Every_days of int
-  | Every_months of int
-  | Every_years of int
-(** Internal type used to represent 'every' expressions. *)
+val (//) : string -> string -> string
+(** [dir // file] concatenates directory and file. *)
 
-type shell_script = {
-  sh_loc : Camlp4.PreCast.Loc.t;
-  sh_script : string;
-}
-(** A shell script. *)
+val isalpha : char -> bool
+val isalnum : char -> bool
+(** Character tests. *)
 
-type variable =
-  | T_bool of bool
-  | T_string of string
-  | T_int of Big_int.big_int
-  | T_float of float
-(** Typed variable (see also [whenproto.x]) *)
-
-val variable_of_rpc : Whenproto_aux.variable -> variable
-val rpc_of_variable : variable -> Whenproto_aux.variable
-
-type variables = variable StringMap.t
-(** A set of variables. *)
-
-type job_private
-(** Private state associated with a job, used for evaluation. *)
-
-val no_job_private : job_private
-(* XXX any use of no_job_private is wrong XXX *)
-
-type job_cond =
-  | When_job of whenexpr                (** when ... : << >> *)
-  | Every_job of periodexpr             (** every ... : << >> *)
-
-type job = {
-  job_loc : Camlp4.PreCast.Loc.t;
-  job_name : string;
-  job_cond : job_cond;
-  job_script : shell_script;
-  job_private : job_private;
-}
-(** A job. *)
-
-val expr_of_ast : Camlp4.PreCast.Ast.Loc.t -> Camlp4.PreCast.Ast.expr -> whenexpr
-(** Convert OCaml AST to an expression.  Since OCaml ASTs are much
-    more general than the expressions we can use, this can raise
-    [Invalid_argument] in many different situations. *)
-
-val string_of_whenexpr : whenexpr -> string
-(** Pretty-print an expression to a string. *)
-
-val string_of_periodexpr : periodexpr -> string
-(** Pretty-print a period expression to a string. *)
-
-val dependencies_of_whenexpr : whenexpr -> string list
-(** Return list of variables that an expression depends on.  This is
-    used to work out when an expression needs to be reevaluated. *)
-
-val dependencies_of_job : job -> string list
-(** Which variables does this job depend on? *)
-
-val job_evaluate : job -> variables -> bool * job
-(** Evaluate [job]'s condition in the context of the [variables], and
-    return [true] iff it should be run now.  Note that this returns a
-    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.
+val filter_map : ('a -> 'b option) -> 'a list -> 'b list
+(** Filter + map. *)
 
-    If [period = Every_days i] then events happen at
-    midnight UTC every [i] days since the Epoch.
-    This returns the next midnight > t.
+val string_of_time_t : ?localtime:bool -> float -> string
+(** Convert string to time in ISO format.  If [~localtime] is true
+    then it uses localtime, else UTC. *)
 
-    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.
+val string_startswith : string -> string -> bool
+(** [string_startswith str prefix] returns true iff [str] starts
+    with [prefix]. *)
 
-    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. *)
+val string_endswith : string -> string -> bool
+(** [string_endswith str suffix] returns true iff [str] ends with [suffix]. *)