sig
module EdosSolver :
sig
module type S = sig type reason end
module type T =
sig
module X : S
type state
type var = int
type value = True | False | Unknown
type lit
val lit_of_var :
Common.EdosSolver.T.var -> bool -> Common.EdosSolver.T.lit
val initialize_problem :
?print_var:(Format.formatter -> int -> unit) ->
?buffer:bool -> int -> Common.EdosSolver.T.state
val copy : Common.EdosSolver.T.state -> Common.EdosSolver.T.state
val propagate : Common.EdosSolver.T.state -> unit
val protect : Common.EdosSolver.T.state -> unit
val reset : Common.EdosSolver.T.state -> unit
val assignment :
Common.EdosSolver.T.state -> Common.EdosSolver.T.value array
val assignment_true :
Common.EdosSolver.T.state -> Common.EdosSolver.T.var list
val add_rule :
Common.EdosSolver.T.state ->
Common.EdosSolver.T.lit array -> X.reason list -> unit
val associate_vars :
Common.EdosSolver.T.state ->
Common.EdosSolver.T.lit -> Common.EdosSolver.T.var list -> unit
val solve_all :
(Common.EdosSolver.T.state -> unit) ->
Common.EdosSolver.T.state -> Common.EdosSolver.T.var -> bool
val solve :
Common.EdosSolver.T.state -> Common.EdosSolver.T.var -> bool
val solve_lst :
Common.EdosSolver.T.state -> Common.EdosSolver.T.var list -> bool
val collect_reasons :
Common.EdosSolver.T.state ->
Common.EdosSolver.T.var -> X.reason list
val collect_reasons_lst :
Common.EdosSolver.T.state ->
Common.EdosSolver.T.var list -> X.reason list
val dump : Common.EdosSolver.T.state -> (int * bool) list list
val debug : bool -> unit
val stats : Common.EdosSolver.T.state -> unit
end
module M :
functor (X : S) ->
sig
module X : sig type reason = X.reason end
type state
type var = int
type value = True | False | Unknown
type lit
val lit_of_var : var -> bool -> lit
val initialize_problem :
?print_var:(Format.formatter -> int -> unit) ->
?buffer:bool -> int -> state
val copy : state -> state
val propagate : state -> unit
val protect : state -> unit
val reset : state -> unit
val assignment : state -> value array
val assignment_true : state -> var list
val add_rule : state -> lit array -> X.reason list -> unit
val associate_vars : state -> lit -> var list -> unit
val solve_all : (state -> unit) -> state -> var -> bool
val solve : state -> var -> bool
val solve_lst : state -> var list -> bool
val collect_reasons : state -> var -> X.reason list
val collect_reasons_lst : state -> var list -> X.reason list
val dump : state -> (int * bool) list list
val debug : bool -> unit
val stats : state -> unit
end
end
module Input :
sig
val std_open_file : string -> IO.input
exception File_empty
val open_file : string -> IO.input
val open_ch : Pervasives.in_channel -> IO.input
val close_ch : IO.input -> unit
val parse_uri :
string ->
Url.filetypes *
(string option * string option * string option * string option *
string) *
string option
val guess_format : string list list -> Url.filetypes
end
module Util :
sig
val uuid : unit -> string
val list_unique : 'a list -> 'a list
val memo : ('a -> 'b) -> 'a -> 'b
val timestamp : unit -> string
type label = string
module type Messages =
sig
type t
val create :
?enabled:bool -> Common.Util.label -> Common.Util.Messages.t
val eprintf :
?raw:bool ->
Common.Util.Messages.t ->
('a, unit, string, unit) Pervasives.format4 -> 'a
val enable : Common.Util.label -> unit
val disable : Common.Util.label -> unit
val all_disabled : unit -> unit
val all_enabled : unit -> unit
val avalaible : unit -> Common.Util.label list
val is_enabled : Common.Util.label -> bool
end
module Debug : Messages
module Warning : Messages
module Info : Messages
module Notice : Messages
module Logging :
functor (X : sig val label : string end) ->
sig
val it : Info.t
val info : ('a, unit, string, unit) Pervasives.format4 -> 'a
val nt : Notice.t
val notice : ('a, unit, string, unit) Pervasives.format4 -> 'a
val wt : Warning.t
val warning : ('a, unit, string, unit) Pervasives.format4 -> 'a
val dt : Debug.t
val debug : ('a, unit, string, unit) Pervasives.format4 -> 'a
val fatal : ('a, unit, string, 'b) Pervasives.format4 -> 'a
end
module Progress :
sig
type t
val create :
?enabled:bool ->
?total:int ->
?unbounded:bool -> Common.Util.label -> Common.Util.Progress.t
val enable : Common.Util.label -> unit
val disable : Common.Util.label -> unit
val set_total : Common.Util.Progress.t -> int -> unit
val progress : ?i:int -> Common.Util.Progress.t -> unit
val reset : Common.Util.Progress.t -> unit
val available : unit -> Common.Util.label list
end
module Timer :
sig
type t
val create : ?enabled:bool -> string -> Common.Util.Timer.t
val enable : Common.Util.label -> unit
val pp_timer : Format.formatter -> Common.Util.Timer.t -> unit
val dump : Format.formatter -> unit -> unit
val start : Common.Util.Timer.t -> unit
val stop : Common.Util.Timer.t -> 'a -> 'a
val available : unit -> Common.Util.label list
end
module IntHashtbl :
sig
type key = int
type 'a t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Hashtbl.statistics
end
module IntPairHashtbl :
sig
type key = int * int
type 'a t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Hashtbl.statistics
end
module StringHashtbl :
sig
type key = string
type 'a t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Hashtbl.statistics
end
module StringPairHashtbl :
sig
type key = string * string
type 'a t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Hashtbl.statistics
end
val range : int -> int -> int list
val string_of_list :
?delim:string * string ->
?sep:string -> ('a -> string) -> 'a list -> string
class type projection =
object
method add : int -> unit
method inttovar : int -> int
method vartoint : int -> int
end
class identity : projection
class intprojection : int -> projection
end
module CudfAdd :
sig
val equal : Cudf.package -> Cudf.package -> bool
val compare : Cudf.package -> Cudf.package -> int
val hash : Cudf.package -> int
val sort : Cudf.package list -> Cudf.package list
module Cudf_hashtbl :
sig
type key = Cudf.package
type 'a t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Hashtbl.statistics
end
module Cudf_set :
sig
type elt = Cudf.package
type t
val empty : t
val is_empty : t -> bool
val mem : elt -> t -> bool
val add : elt -> t -> t
val singleton : elt -> t
val remove : elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val min_elt : t -> elt
val max_elt : t -> elt
val choose : t -> elt
val split : elt -> t -> t * bool * t
val find : elt -> t -> elt
val of_list : elt list -> t
end
val to_set :
Common.CudfAdd.Cudf_set.elt list -> Common.CudfAdd.Cudf_set.t
val who_provides :
Cudf.universe -> Cudf_types.vpkg -> Cudf.package list
val resolve_deps :
Cudf.universe -> Cudf_types.vpkglist -> Cudf.package list
val who_depends :
Cudf.universe -> Cudf.package -> Cudf.package list list
type ctable = (int, int list Pervasives.ref) ExtLib.Hashtbl.t
val init_conflicts : Cudf.universe -> Common.CudfAdd.ctable
val who_conflicts :
Common.CudfAdd.ctable ->
Cudf.universe -> Cudf.package -> Cudf.package list
val resolve_vpkg_int : Cudf.universe -> Cudf_types.vpkg -> int list
val resolve_vpkgs_int :
Cudf.universe -> Cudf_types.vpkglist -> int list
val encode : string -> string
val decode : string -> string
val latest : Cudf.package list -> Cudf.package list
module StringSet :
sig
type elt = ExtLib.String.t
type t
val empty : t
val is_empty : t -> bool
val mem : elt -> t -> bool
val add : elt -> t -> t
val singleton : elt -> t
val remove : elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val min_elt : t -> elt
val max_elt : t -> elt
val choose : t -> elt
val split : elt -> t -> t * bool * t
val find : elt -> t -> elt
val of_list : elt list -> t
end
val pkgnames : Cudf.universe -> Common.CudfAdd.StringSet.t
val add_properties :
Cudf.preamble -> Cudf_types.typedecl -> Cudf.preamble
val get_property : string -> Cudf.package -> string
val is_essential : Cudf.package -> bool
val realversionmap :
Cudf.package list ->
(Cudf_types.pkgname * string, Cudf.package) ExtLib.Hashtbl.t
val vartoint : Cudf.universe -> Cudf.package -> int
val inttovar : Cudf.universe -> int -> Cudf.package
val cudfop :
(string * string) option ->
([> `Eq | `Geq | `Gt | `Leq | `Lt | `Neq ] * string) option
val compute_pool :
Cudf.universe -> int list list array * int list array
val add_to_package_list :
('a, 'b list Pervasives.ref) ExtLib.Hashtbl.t -> 'a -> 'b -> unit
val get_package_list :
('a, 'b list Pervasives.ref) ExtLib.Hashtbl.t -> 'a -> 'b list
val normalize_set : int list -> int list
val string_of : (Format.formatter -> 'a -> 'b) -> 'a -> string
val pp_version : Format.formatter -> Cudf.package -> unit
val pp_package : Format.formatter -> Cudf.package -> unit
val string_of_version : Cudf.package -> string
val string_of_package : Cudf.package -> string
type pp =
Cudf.package -> string * string * (string * (string * bool)) list
val pp :
(Cudf_types.pkgname * Cudf_types.version -> string * string) ->
?fields:string list ->
?decode:(Cudf_types.pkgname -> string) -> Common.CudfAdd.pp
val default_pp : Common.CudfAdd.pp
val pp_vpkg :
Common.CudfAdd.pp -> Format.formatter -> Cudf_types.vpkg -> unit
val pp_vpkglist :
Common.CudfAdd.pp -> Format.formatter -> Cudf_types.vpkglist -> unit
end
module CudfDiff :
sig
type changeset = Common.CudfAdd.Cudf_set.t * Common.CudfAdd.Cudf_set.t
type difference =
(Cudf_types.pkgname, Common.CudfDiff.changeset) ExtLib.Hashtbl.t
val make_solution :
universe:Cudf.universe ->
solution:Cudf.universe -> Common.CudfDiff.changeset
val make_difference :
universe:Cudf.universe ->
solution:Cudf.universe -> Common.CudfDiff.difference
type summary = {
install : Cudf.package list;
remove : Cudf.package list;
upgrade : (Cudf.package * Cudf.package) list;
downgrade : (Cudf.package * Cudf.package) list;
notchange : Cudf.package list;
}
val make_summary :
Cudf.universe ->
Common.CudfDiff.difference -> Common.CudfDiff.summary
end
module Url :
sig
type debtypes = [ `Deb | `DebSrc | `Edsp ]
type rpmtypes = [ `Hdlist | `Synthesis ]
type othertypes = [ `Csw | `Opam | `Pef ]
type filetypes =
[ `Csw
| `Cudf
| `Deb
| `DebSrc
| `Edsp
| `Hdlist
| `Opam
| `Pef
| `Synthesis ]
val supported_input_types : Common.Url.filetypes list
type url = { scheme : Common.Url.filetypes; path : string; }
val of_string : string -> Common.Url.url
exception Invalid_url of string
val to_string : Common.Url.url -> string
val scheme_to_string : Common.Url.filetypes -> string
val scheme_of_string : string -> Common.Url.filetypes
end
module Criteria :
sig
val parse_criteria : Format822.field -> Criteria_types.criteria
val to_string : ?solver:string -> Criteria_types.criteria -> string
val iter :
(string * string * string * Re.re option -> unit) ->
Criteria_types.criteria -> unit
val is_misc2012 : string -> bool
val default_criteria : (string * Criteria_types.criteria) list
end
end