sig
exception Conflicting_information of string
type liquid = RPM | Debian | Pkgsrc
module type ORDERED_LITERATE =
sig
type t
val compare :
Rapids.ORDERED_LITERATE.t -> Rapids.ORDERED_LITERATE.t -> int
val scribe :
'a Conduit.conduit -> 'a -> Rapids.ORDERED_LITERATE.t -> unit
val io : Rapids.ORDERED_LITERATE.t Io.literate
end
module type STRING_ORDERED_LITERATE =
sig
type t = string
val compare :
Rapids.STRING_ORDERED_LITERATE.t ->
Rapids.STRING_ORDERED_LITERATE.t -> int
val scribe :
'a Conduit.conduit -> 'a -> Rapids.STRING_ORDERED_LITERATE.t -> unit
val io : string Io.literate
end
module Version_order :
sig
type t = string
val compare : Rapids.Version_order.t -> Rapids.Version_order.t -> int
val set_comparator :
(Rapids.Version_order.t -> Rapids.Version_order.t -> int) -> unit
val scribe : 'a Conduit.conduit -> 'a -> Rapids.Version_order.t -> unit
val io : string Io.literate
end
module Release_order :
sig
type t = string option
val compare : Rapids.Release_order.t -> Rapids.Release_order.t -> int
val set_comparator :
(Rapids.Release_order.t -> Rapids.Release_order.t -> int) -> unit
val scribe : 'a Conduit.conduit -> 'a -> Rapids.Release_order.t -> unit
val io : string option Io.literate
end
module type SET =
sig
type elt
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 io : t Io.literate
end
module type ID =
sig
type id
val to_int : Rapids.ID.id -> int
val from_int : int -> Rapids.ID.id
val compare : Rapids.ID.id -> Rapids.ID.id -> int
val succ : Rapids.ID.id -> Rapids.ID.id
val scribe : 'a Conduit.conduit -> 'a -> Rapids.ID.id -> unit
val zero : Rapids.ID.id
val sweep : Rapids.ID.id -> (Rapids.ID.id -> unit) -> unit
val io : Rapids.ID.id Io.literate
end
module type INDEX =
sig
type elt
type id
type t
val create : unit -> Rapids.INDEX.t
val register : Rapids.INDEX.t -> Rapids.INDEX.elt -> Rapids.INDEX.id
val search : Rapids.INDEX.t -> Rapids.INDEX.elt -> Rapids.INDEX.id
val find : Rapids.INDEX.t -> Rapids.INDEX.id -> Rapids.INDEX.elt
val compare_id : Rapids.INDEX.id -> Rapids.INDEX.id -> int
val scribe_id : 'a Conduit.conduit -> 'a -> Rapids.INDEX.id -> unit
val io_id : Rapids.INDEX.id Io.literate
val iter :
Rapids.INDEX.t ->
(Rapids.INDEX.id -> Rapids.INDEX.elt -> unit) -> unit
val set_watcher :
Rapids.INDEX.t ->
(Rapids.INDEX.id -> Rapids.INDEX.elt -> unit) -> unit
end
module type DOUBLE_INDEX =
sig
type e1
type e2
type elt = Rapids.DOUBLE_INDEX.e1 * Rapids.DOUBLE_INDEX.e2
type id
type t
val create : unit -> Rapids.DOUBLE_INDEX.t
val register :
Rapids.DOUBLE_INDEX.t ->
Rapids.DOUBLE_INDEX.elt -> Rapids.DOUBLE_INDEX.id
val replace : Rapids.DOUBLE_INDEX.t -> Rapids.DOUBLE_INDEX.elt -> unit
val find :
Rapids.DOUBLE_INDEX.t ->
Rapids.DOUBLE_INDEX.id -> Rapids.DOUBLE_INDEX.elt
val search1 :
Rapids.DOUBLE_INDEX.t ->
Rapids.DOUBLE_INDEX.e1 -> Rapids.DOUBLE_INDEX.id
val search2 :
Rapids.DOUBLE_INDEX.t ->
Rapids.DOUBLE_INDEX.e2 -> Rapids.DOUBLE_INDEX.id
val compare_id :
Rapids.DOUBLE_INDEX.id -> Rapids.DOUBLE_INDEX.id -> int
val scribe_id :
'a Conduit.conduit -> 'a -> Rapids.DOUBLE_INDEX.id -> unit
val iter :
Rapids.DOUBLE_INDEX.t ->
(Rapids.DOUBLE_INDEX.id -> Rapids.DOUBLE_INDEX.elt -> unit) -> unit
val set_watcher :
Rapids.DOUBLE_INDEX.t ->
(Rapids.DOUBLE_INDEX.id -> Rapids.DOUBLE_INDEX.elt -> unit) -> unit
end
module type VERSION_POOL =
sig
type version
type handle
type id
type t
val create : unit -> Rapids.VERSION_POOL.t
val register :
Rapids.VERSION_POOL.t ->
Rapids.VERSION_POOL.version -> Rapids.VERSION_POOL.handle
val search :
Rapids.VERSION_POOL.t ->
Rapids.VERSION_POOL.version -> Rapids.VERSION_POOL.handle
val compare_versions :
Rapids.VERSION_POOL.t ->
Rapids.VERSION_POOL.handle -> Rapids.VERSION_POOL.handle -> int
val find :
Rapids.VERSION_POOL.t ->
Rapids.VERSION_POOL.id -> Rapids.VERSION_POOL.handle
val get_version :
Rapids.VERSION_POOL.handle -> Rapids.VERSION_POOL.version
val get_id : Rapids.VERSION_POOL.handle -> Rapids.VERSION_POOL.id
val iter :
Rapids.VERSION_POOL.t -> (Rapids.VERSION_POOL.handle -> unit) -> unit
val scribe_id :
'a Conduit.conduit -> 'a -> Rapids.VERSION_POOL.id -> unit
val io_id : Rapids.VERSION_POOL.id Io.literate
end
module type LABELED_INDEX =
sig
type data
type elt
type id
type t
val create : unit -> Rapids.LABELED_INDEX.t
val register :
Rapids.LABELED_INDEX.t ->
Rapids.LABELED_INDEX.elt ->
(unit -> Rapids.LABELED_INDEX.data) -> Rapids.LABELED_INDEX.id
val search :
Rapids.LABELED_INDEX.t ->
Rapids.LABELED_INDEX.elt -> Rapids.LABELED_INDEX.id
val find :
Rapids.LABELED_INDEX.t ->
Rapids.LABELED_INDEX.id -> Rapids.LABELED_INDEX.elt
val data :
Rapids.LABELED_INDEX.t ->
Rapids.LABELED_INDEX.id -> Rapids.LABELED_INDEX.data
val compare_id :
Rapids.LABELED_INDEX.id -> Rapids.LABELED_INDEX.id -> int
val scribe_id :
'a Conduit.conduit -> 'a -> Rapids.LABELED_INDEX.id -> unit
val io_id : Rapids.LABELED_INDEX.id Io.literate
val iter :
Rapids.LABELED_INDEX.t ->
(Rapids.LABELED_INDEX.id ->
Rapids.LABELED_INDEX.elt -> Rapids.LABELED_INDEX.data -> unit) ->
unit
val set_watcher :
Rapids.LABELED_INDEX.t ->
(Rapids.LABELED_INDEX.id ->
Rapids.LABELED_INDEX.elt -> Rapids.LABELED_INDEX.data -> unit) ->
unit
end
module type CHRONOLOGICAL_MAP =
sig
type t
type set
type elt
type day = int
val io : Rapids.CHRONOLOGICAL_MAP.t Io.literate
val create : unit -> Rapids.CHRONOLOGICAL_MAP.t
val iter :
(Rapids.CHRONOLOGICAL_MAP.day -> Rapids.CHRONOLOGICAL_MAP.set -> unit) ->
Rapids.CHRONOLOGICAL_MAP.t -> unit
val range :
Rapids.CHRONOLOGICAL_MAP.t ->
Rapids.CHRONOLOGICAL_MAP.day * Rapids.CHRONOLOGICAL_MAP.day
val get :
Rapids.CHRONOLOGICAL_MAP.t ->
Rapids.CHRONOLOGICAL_MAP.day -> Rapids.CHRONOLOGICAL_MAP.set
val add :
Rapids.CHRONOLOGICAL_MAP.t ->
Rapids.CHRONOLOGICAL_MAP.day ->
Rapids.CHRONOLOGICAL_MAP.day -> Rapids.CHRONOLOGICAL_MAP.set -> unit
end
type archive_name = string
type architecture_name = string
type unit_name = string
type version_name = string
type source_name = Rapids.unit_name * Rapids.version_name
type source_version_name = Rapids.version_name
type version_number
type release_number
type version_id
type release_id
type unit_id
type source_id
type architecture_id
type package_id
type archive_id
type glob = string
type archive
module Architecture_name :
sig
type t = architecture_name
val compare : t -> t -> int
val scribe : 'a Conduit.conduit -> 'a -> t -> unit
val io : t Io.literate
end
module Architecture_index :
sig
type elt = architecture_name
type id = architecture_id
type t
val create : unit -> t
val register : t -> elt -> id
val search : t -> elt -> id
val find : t -> id -> elt
val compare_id : id -> id -> int
val scribe_id : 'a Conduit.conduit -> 'a -> id -> unit
val io_id : id Io.literate
val iter : t -> (id -> elt -> unit) -> unit
val set_watcher : t -> (id -> elt -> unit) -> unit
end
module Unit_name :
sig
type t = unit_name
val compare : t -> t -> int
val scribe : 'a Conduit.conduit -> 'a -> t -> unit
val io : t Io.literate
end
module Package_ID :
sig
type id = package_id
val to_int : id -> int
val from_int : int -> id
val compare : id -> id -> int
val succ : id -> id
val scribe : 'a Conduit.conduit -> 'a -> id -> unit
val zero : id
val sweep : id -> (id -> unit) -> unit
val io : id Io.literate
end
module Package_set :
sig
type elt = package_id
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 io : t Io.literate
end
module Unit_index :
sig
type data
type elt = unit_name
type id = unit_id
type t
val create : unit -> t
val register : t -> elt -> (unit -> data) -> id
val search : t -> elt -> id
val find : t -> id -> elt
val data : t -> id -> data
val compare_id : id -> id -> int
val scribe_id : 'a Conduit.conduit -> 'a -> id -> unit
val io_id : id Io.literate
val iter : t -> (id -> elt -> data -> unit) -> unit
val set_watcher : t -> (id -> elt -> data -> unit) -> unit
end
module Unit_set :
sig
type elt = unit_id
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 io : t Io.literate
end
module Source_name :
sig
type t = source_name
val compare : t -> t -> int
val scribe : 'a Conduit.conduit -> 'a -> t -> unit
val io : t Io.literate
end
module Source_index :
sig
type elt = source_name
type id = source_id
type t
val create : unit -> t
val register : t -> elt -> id
val search : t -> elt -> id
val find : t -> id -> elt
val compare_id : id -> id -> int
val scribe_id : 'a Conduit.conduit -> 'a -> id -> unit
val io_id : id Io.literate
val iter : t -> (id -> elt -> unit) -> unit
val set_watcher : t -> (id -> elt -> unit) -> unit
end
module Source_set :
sig
type elt = source_id
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 io : t Io.literate
end
module Version_index :
sig
type version = string
type handle = version_number
type id = version_id
type t
val create : unit -> t
val register : t -> version -> handle
val search : t -> version -> handle
val compare_versions : t -> handle -> handle -> int
val find : t -> id -> handle
val get_version : handle -> version
val get_id : handle -> id
val iter : t -> (handle -> unit) -> unit
val scribe_id : 'a Conduit.conduit -> 'a -> id -> unit
val io_id : id Io.literate
end
module Release_index :
sig
type version = string option
type handle = release_number
type id = release_id
type t
val create : unit -> t
val register : t -> version -> handle
val search : t -> version -> handle
val compare_versions : t -> handle -> handle -> int
val find : t -> id -> handle
val get_version : handle -> version
val get_id : handle -> id
val iter : t -> (handle -> unit) -> unit
val scribe_id : 'a Conduit.conduit -> 'a -> id -> unit
val io_id : id Io.literate
end
module Archive_index :
sig
type data = archive
type elt = archive_name
type id = archive_id
type t
val create : unit -> t
val register : t -> elt -> (unit -> data) -> id
val search : t -> elt -> id
val find : t -> id -> elt
val data : t -> id -> data
val compare_id : id -> id -> int
val scribe_id : 'a Conduit.conduit -> 'a -> id -> unit
val io_id : id Io.literate
val iter : t -> (id -> elt -> data -> unit) -> unit
val set_watcher : t -> (id -> elt -> data -> unit) -> unit
end
module Archive_set :
sig
type elt = archive_id
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 io : t Io.literate
end
type package_name =
Rapids.unit_id * Rapids.version_id * Rapids.release_id *
Rapids.architecture_id
type package_extra
type package =
(Rapids.package_extra, Rapids.unit_id,
Rapids.version_number * Rapids.release_number, Rapids.glob,
Rapids.architecture_id, Rapids.source_id)
Napkin.package
module Package_index :
sig
type e1 = package_name
type e2 = package
type elt = e1 * e2
type id = package_id
type t
val create : unit -> t
val register : t -> elt -> id
val replace : t -> elt -> unit
val find : t -> id -> elt
val search1 : t -> e1 -> id
val search2 : t -> e2 -> id
val compare_id : id -> id -> int
val scribe_id : 'a Conduit.conduit -> 'a -> id -> unit
val iter : t -> (id -> elt -> unit) -> unit
val set_watcher : t -> (id -> elt -> unit) -> unit
end
type package_set = Rapids.Package_set.t
type unit_set = Rapids.Unit_set.t
type source_set = Rapids.Source_set.t
type archive_set = Rapids.Archive_set.t
module Chronology :
sig
type t
type set = Package_set.t
type elt = Package_ID.id
type day = int
val io : t Io.literate
val create : unit -> t
val iter : (day -> set -> unit) -> t -> unit
val range : t -> day * day
val get : t -> day -> set
val add : t -> day -> day -> set -> unit
end
type db
val create_database : unit -> Rapids.db
val add_package : Rapids.db -> Napkin.default_package -> Rapids.package_id
val replace_package : Rapids.db -> Rapids.package -> unit
val self_test : Rapids.db -> unit
val get_liquid : Rapids.db -> Rapids.liquid option
val get_package_index : Rapids.db -> Rapids.Package_index.t
val get_unit_index : Rapids.db -> Rapids.Unit_index.t
val get_version_index : Rapids.db -> Rapids.Version_index.t
val get_release_index : Rapids.db -> Rapids.Release_index.t
val get_architecture_index : Rapids.db -> Rapids.Architecture_index.t
val get_archive_index : Rapids.db -> Rapids.Archive_index.t
val get_source_index : Rapids.db -> Rapids.Source_index.t
val set_liquid : Rapids.db -> Rapids.liquid -> unit
val split_version : string -> string * string option
val add_archive : Rapids.db -> Rapids.archive_name -> Rapids.archive_id
val get_archive : Rapids.db -> Rapids.archive_id -> Rapids.archive
val get_archive_contents :
Rapids.archive -> Lifetime.day -> Rapids.package_set
val iterate_over_archive :
(Lifetime.day -> Rapids.package_set -> unit) -> Rapids.archive -> unit
val archive_range :
Rapids.db -> Rapids.archive -> Lifetime.day * Lifetime.day
val add_packages_to_archive :
Rapids.db ->
Rapids.archive -> Rapids.package_set -> Lifetime.lifetime -> unit
module Functions :
sig
val packages : Rapids.db -> Rapids.package_set
val units : Rapids.db -> Rapids.unit_set
val sources : Rapids.db -> Rapids.source_set
val archives : Rapids.db -> Rapids.archive_set
val unit_id_to_package_set :
Rapids.db -> Rapids.unit_id -> Rapids.package_set
val unit_id_to_providers :
Rapids.db ->
Rapids.unit_id ->
(Rapids.package_id, Rapids.version_number * Rapids.release_number,
Rapids.glob)
Napkin.versioned list
val select :
Rapids.db ->
(Rapids.Unit_index.id,
Rapids.Version_index.handle * Rapids.Release_index.handle, string)
Napkin.versioned -> Rapids.package_set
val dependency_closure :
Rapids.db ->
?relations:[ `Dep | `Pre ] list ->
Rapids.package_set -> Rapids.package_set
val dependency_path :
?conjunctive:bool ->
Rapids.db ->
Rapids.package_set ->
Rapids.package_id ->
Rapids.package_id -> Rapids.package_id list option
val conflicts : Rapids.db -> Rapids.package_set -> Rapids.package_set
val get_package_from_id :
Rapids.db -> Rapids.package_id -> Rapids.package
val scribe_package :
Rapids.db ->
'a Conduit.conduit ->
'a ->
?default_architecture:Rapids.architecture_id ->
Rapids.package -> unit
val scribe_package_from_id :
Rapids.db ->
'a Conduit.conduit ->
'a ->
?default_architecture:Rapids.architecture_id ->
Rapids.package_id -> unit
val scribe_unit_from_id :
Rapids.db -> 'a Conduit.conduit -> 'a -> Rapids.unit_id -> unit
val scribe_archive_from_id :
Rapids.db -> 'a Conduit.conduit -> 'a -> Rapids.archive_id -> unit
val scribe_source_from_id :
Rapids.db -> 'a Conduit.conduit -> 'a -> Rapids.source_id -> unit
val scribe_version_from_number :
Rapids.db ->
'a Conduit.conduit ->
'a -> Rapids.version_number * Rapids.release_number -> unit
end
end