opam-solver 2.2.1 · OCaml Package

Entry point to the solver, conversion of opam package universes to Cudf, dependencies computation. Front-end to Dose.

module Action : OpamActionGraph.ACTION with type package = OpamTypes.package

module ActionGraph : OpamActionGraph.SIG with type package = OpamTypes.package

type solution

val empty_universe : OpamTypes.universe

Solver

val string_of_request : OpamTypes.atom OpamTypes.request -> string

Convert a request to a string

val stats : solution -> OpamTypes.stats

Compute statistics about a solution

val new_packages : solution -> OpamTypes.package_set

Return the new packages in the solution

val removed_packages : solution -> OpamTypes.package_set

Return removed new packages in the solution

val all_packages : solution -> OpamTypes.package_set

Return all packages appearing in the solution

val string_of_stats : OpamTypes.stats -> string

Pretty-printing of statistics

val solution_is_empty : solution -> bool

Is the solution empty?

val print_solution : 
  messages:(OpamTypes.package -> string list) ->
  append:(OpamTypes.package -> string) ->
  requested:OpamTypes.name_set ->
  reinstall:OpamTypes.package_set ->
  available:OpamTypes.package_set ->
  ?skip:OpamTypes.package OpamPackage.Map.t ->
  solution ->
  unit

Display a solution. skip skips printing the actions on the given packages and replaces their names in other places where they appear

val solution_to_json : solution OpamJson.encoder

Serialize a solution

val solution_of_json : solution OpamJson.decoder

val cudf_versions_map : OpamTypes.universe -> int OpamPackage.Map.t

Computes an opam->cudf version map from an universe

val load_cudf_universe : 
  OpamTypes.universe ->
  ?version_map:int OpamTypes.package_map ->
  OpamTypes.package_set ->
  ?add_invariant:bool ->
  ?depopts:bool ->
  build:bool ->
  post:bool ->
  unit ->
  Cudf.universe

Creates a CUDF universe from an OPAM universe, including the given packages. Evaluation of the first 3 arguments is staged. Warning: when depopts is true, the optional dependencies may become strong dependencies.

Use add_invariant if you expect to call the solver and need the switch invariants to be respected; remember in that case to call Cudf.remove_package universe OpamCudf.opam_invariant_package before exporting the results

val request : 
  ?criteria:OpamTypes.solver_criteria ->
  ?install:OpamTypes.atom list ->
  ?upgrade:OpamTypes.atom list ->
  ?remove:OpamTypes.atom list ->
  ?deprequest:OpamTypes.atom OpamFormula.formula ->
  ?all:OpamTypes.atom list ->
  unit ->
  OpamTypes.atom OpamTypes.request

Build a request. all defaults to all atoms concerned by any action, and is used for limiting the solution to the relevant packages, an empty list implying all actions are relevant (no trimming)

val resolve : 
  OpamTypes.universe ->
  OpamTypes.atom OpamTypes.request ->
  (solution, OpamCudf.conflict) OpamTypes.result

Given a description of packages, return a solution preserving the consistency of the initial description.

val get_atomic_action_graph : solution -> ActionGraph.t

Returns the graph of atomic actions (rm, inst) from a solution

val installable : OpamTypes.universe -> OpamTypes.package_set

Keep only the packages that are installable.

val installable_subset : 
  OpamTypes.universe ->
  OpamTypes.package_set ->
  OpamTypes.package_set

Like installable, but within a subset and potentially much faster

val dependency_sort : 
  depopts:bool ->
  build:bool ->
  post:bool ->
  OpamTypes.universe ->
  OpamTypes.package_set ->
  OpamTypes.package list

Sorts the given package set in topological order (as much as possible, beware of cycles in particular if post is true)

module PkgGraph : Graph.Sig.I with type V.t = OpamPackage.t

val dependency_graph : 
  depopts:bool ->
  build:bool ->
  post:bool ->
  installed:bool ->
  ?unavailable:bool ->
  OpamTypes.universe ->
  PkgGraph.t

val check_for_conflicts : OpamTypes.universe -> OpamCudf.conflict option

Check the current set of installed packages in a universe for inconsistencies

val coinstallability_check : 
  OpamTypes.universe ->
  OpamTypes.package_set ->
  OpamCudf.conflict option

Checks the given package set for complete installability ; returns None if they can all be installed together

val atom_coinstallability_check : 
  OpamTypes.universe ->
  OpamTypes.atom list ->
  bool

Checks if the given atoms can be honored at the same time in the given universe

val coinstallable_subset : 
  OpamTypes.universe ->
  ?add_invariant:bool ->
  OpamTypes.package_set ->
  OpamTypes.package_set ->
  OpamTypes.package_set

coinstallable_subset univ set packages returns the subset of packages which are individually co-installable with set, i.e. that can be installed while set remains installed. This returns the empty set if set is already not coinstallable. `add_invariant` defaults to true

val dump_universe : OpamTypes.universe -> Stdlib.out_channel -> unit

Dumps a cudf file containing all available packages in the given universe, plus version bindings (as '#v2v' comments) for the other ones.

val filter_solution : 
  ?recursive:bool ->
  (OpamTypes.package -> bool) ->
  solution ->
  solution

Filters actions in a solution. Dependents of a removed actions are removed to keep consistency unless recursive is set to false

package opam-solver

Solver