package opam-0install

You can search for identifiers within the package.

in-package search v0.2.0

On This Page

Parameters
Signature

opam-0install
- Opam_0install
  - Dir_context
  - Model
    
    Make
    
    Context
    
    Role
  - S
    
    CONTEXT
    
    SOLVER
  - Solver
    
    Make
    
    C
    
    Diagnostics
    
    Component
    
    Note
    
    Input
    
    Role
    
    Solver
    
    Output
    
    RoleMap
  - Switch_context

Legend:
Library
Module
Module type
Parameter
Class
Class type

Parameters

module Context : S.CONTEXT

Signature

include Zeroinstall_solver.S.SOLVER_INPUT
  with type rejection = Context.rejection

include Zeroinstall_solver.S.CORE_MODEL

module Role : sig ... end

type impl

An impl is something that can fill a Role.t (e.g. a particular version of a package).

type command

A command is an entry-point provided by an implementation. Using a command may require extra dependencies (for example, a "test" command might depend on a test runner).

type command_name = private string

An identifier for a command within a role. Note: It might not be necessary to use any commands - we could instead treat the command name as an optional part of the role, and treat each command as a separate impl instead.

type dependency

A dependency indicates that an impl or command requires another role to be filled.

type dep_info = {

dep_role : Role.t;
dep_importance : [ `Essential | `Recommended | `Restricts ];
dep_required_commands : command_name list;

}

type requirements = {

role : Role.t;
command : command_name option;

}

val requires : Role.t -> impl -> dependency list * command_name list

Get an implementation's dependencies.

The dependencies should be ordered with the most important first. The solver will prefer to select the best possible version of an earlier dependency, even if that means selecting a worse version of a later one (restricts_only dependencies are ignored for this).

An implementation or command can also bind to itself. e.g. "test" command that requires its own "run" command. We also return all such required commands.

val dep_info : dependency -> dep_info

val command_requires : Role.t -> command -> dependency list * command_name list

As requires, but for commands.

val get_command : impl -> command_name -> command option

type role_information = {

replacement : Role.t option;
(*
Another role that conflicts with this one.
*)
impls : impl list;
(*
Candidates to fill the role.
*)

}

Information provided to the solver about a role.

type restriction

A restriction limits which implementations can fill a role.

type machine_group = private string

The solver will avoid selections with mixed machine groups. This is useful if e.g. the CPU supports 32-bit and 64-bit programs, but we can't mix them in a single process. The string simply has to be unique for each group (e.g. "32" and "64").

val pp_impl : Format.formatter -> impl -> unit

val pp_command : Format.formatter -> command -> unit

val implementations : Role.t -> role_information

The list of candidates to fill a role.

val restrictions : dependency -> restriction list

Restrictions on how the role is filled

val meets_restriction : impl -> restriction -> bool

val machine_group : impl -> machine_group option

type conflict_class = private string

There can be only one implementation in each conflict class.

val conflict_class : impl -> conflict_class list

The following are used for diagnostics only

type rejection = Context.rejection

The reason why the model rejected an implementation before it got to the solver. For example, the implementation was a Windows binary but the host is Linux.

val rejects : Role.t -> (impl * rejection) list * string list

Get the candidates which were rejected for a role (and not passed to the solver), as well as any general notes and warnings not tied to a particular impl.

val compare_version : impl -> impl -> int

Used to sort the results.

val pp_version : Format.formatter -> impl -> unit

val user_restrictions : Role.t -> restriction option

Get any user-specified restrictions affecting a role. These are used to filter out implementations before they get to the solver.

val pp_impl_long : Format.formatter -> impl -> unit

A detailed identifier for the implementation. In 0install, this is the version number and part of the hash.

val format_machine : impl -> string

val string_of_restriction : restriction -> string

val describe_problem : impl -> rejection -> string

val dummy_impl : impl

A dummy implementation, used to get diagnostic information if the solve fails. It satisfies all requirements, even conflicting ones.

val role : Context.t -> OpamPackage.Name.t -> Role.t

val version : impl -> OpamPackage.t option

version impl is the Opam package for impl, if any. Virtual and dummy implementations return None.

val virtual_role : impl list -> Role.t

virtual_role impls is a virtual package name with candidates impls. This is used if the user requests multiple packages on the command line (the single impl will also be virtual).

val virtual_impl : 
  context:Context.t ->
  depends:OpamPackage.Name.t list ->
  unit ->
  impl

virtual_impl ~context ~depends () is a virtual package which just depends on depends. This is used if the user requests multiple packages on the command line - each requested package becomes a dependency of the virtual implementation.

val package_name : Role.t -> OpamPackage.Name.t option

package_name role is the Opam package name for role, if any. Return None on virtual roles.

val formula : 
  restriction ->
  [ `Ensure | `Prevent ] * OpamFormula.version_formula

formula restriction returns the version formula represented by this restriction along with its negation status: (`Prevent, formula) roughly means not formula.