sig
type t
type project = Project.t
val ty : Project.t Type.t
val dummy : Project.t
module type KIND =
sig
type t
val dummy : Project.KIND.t
val name : Project.KIND.t -> string
val add_dependency : Project.KIND.t -> Project.KIND.t -> unit
end
val identity : 'a -> 'a
val is_identity : ('a -> 'a) -> bool
module Datatype :
sig
module type INPUT =
sig
type t
val rehash : Project.Datatype.INPUT.t -> Project.Datatype.INPUT.t
val descr : Unmarshal.t
val copy : Project.Datatype.INPUT.t -> Project.Datatype.INPUT.t
val name : string
end
module type S =
sig
type t
val rehash : t -> t
val descr : Unmarshal.t
val copy : t -> t
val name : string
val register_comparable :
?compare:(Project.t -> Project.t -> int) ->
?equal:(Project.t -> Project.t -> bool) ->
?hash:(Project.t -> int) ->
?physical_hash:(Project.t -> int) -> unit -> unit
val is_comparable_set : unit -> bool
val hash : Project.t -> int
val physical_hash : Project.t -> int
val equal : Project.t -> Project.t -> bool
val compare : Project.t -> Project.t -> int
val contain_project :
(Project.project -> Project.t -> bool) option Pervasives.ref
end
module Register :
functor (Datatype : INPUT) ->
sig
type t = Datatype.t
val rehash : t -> t
val descr : Unmarshal.t
val copy : t -> t
val name : string
val register_comparable :
?compare:(t -> t -> int) ->
?equal:(t -> t -> bool) ->
?hash:(t -> int) -> ?physical_hash:(t -> int) -> unit -> unit
val is_comparable_set : unit -> bool
val hash : t -> int
val physical_hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
val contain_project : (project -> t -> bool) option ref
end
module Imperative :
functor
(X : sig
type t
val copy :
Project.Datatype.Imperative.t ->
Project.Datatype.Imperative.t
val name : string
end) ->
sig
type t = X.t
val rehash : t -> t
val descr : Unmarshal.t
val copy : t -> t
val name : string
val register_comparable :
?compare:(t -> t -> int) ->
?equal:(t -> t -> bool) ->
?hash:(t -> int) -> ?physical_hash:(t -> int) -> unit -> unit
val is_comparable_set : unit -> bool
val hash : t -> int
val physical_hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
val contain_project : (project -> t -> bool) option ref
end
module Persistent :
functor (X : sig type t val name : string end) ->
sig
type t = X.t
val rehash : t -> t
val descr : Unmarshal.t
val copy : t -> t
val name : string
val register_comparable :
?compare:(t -> t -> int) ->
?equal:(t -> t -> bool) ->
?hash:(t -> int) -> ?physical_hash:(t -> int) -> unit -> unit
val is_comparable_set : unit -> bool
val hash : t -> int
val physical_hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
val contain_project : (project -> t -> bool) option ref
end
module Own :
sig
type t = project
val rehash : t -> t
val descr : Unmarshal.t
val copy : t -> t
val name : string
val register_comparable :
?compare:(t -> t -> int) ->
?equal:(t -> t -> bool) ->
?hash:(t -> int) -> ?physical_hash:(t -> int) -> unit -> unit
val is_comparable_set : unit -> bool
val hash : t -> int
val physical_hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
val contain_project : (project -> t -> bool) option ref
end
val extend_name : string -> string -> string
val extend_name2 : string -> string -> string -> string
val extend_name3 : string -> string -> string -> string -> string
end
module Computation :
sig
type t
val dummy : t
val name : t -> string
val add_dependency : t -> t -> unit
type selection
module type INPUT =
sig
type t
val create : unit -> Project.Computation.INPUT.t
val clear : Project.Computation.INPUT.t -> unit
val get : unit -> Project.Computation.INPUT.t
val set : Project.Computation.INPUT.t -> unit
val clear_if_project :
Project.project -> Project.Computation.INPUT.t -> bool
end
module type INFO =
sig val name : string val dependencies : Project.t list end
module type OUTPUT =
sig
val self : Project.t
val select :
Kind.how ->
Project.Computation.selection -> Project.Computation.selection
val depend : Project.t -> unit
val mark_as_computed : ?project:Project.project -> unit -> unit
val is_computed : ?project:Project.project -> unit -> bool
val do_not_save : unit -> unit
module Datatype : Datatype.S
val name : string
end
module Register :
functor (Datatype : Datatype.S) ->
functor
(State : sig
type t = Datatype.t
val create : unit -> t
val clear : t -> unit
val get : unit -> t
val set : t -> unit
val clear_if_project : project -> t -> bool
end) ->
functor (Info : INFO) ->
sig
val self : t
val select : Kind.how -> selection -> selection
val depend : t -> unit
val mark_as_computed : ?project:project -> unit -> unit
val is_computed : ?project:project -> unit -> bool
val do_not_save : unit -> unit
module Datatype :
sig
type t = Datatype.t
val rehash : t -> t
val descr : Unmarshal.t
val copy : t -> t
val name : string
val register_comparable :
?compare:(t -> t -> int) ->
?equal:(t -> t -> bool) ->
?hash:(t -> int) ->
?physical_hash:(t -> int) -> unit -> unit
val is_comparable_set : unit -> bool
val hash : t -> int
val physical_hash : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int
val contain_project : (project -> t -> bool) option ref
end
val name : string
end
val dump_dependencies :
?only:Project.Computation.selection ->
?except:Project.Computation.selection -> string -> unit
end
module Selection :
sig
type kind = Computation.t
type t = Computation.selection
val ty : t Type.t
val empty : t
val is_empty : t -> bool
val add : kind -> Kind.how -> t -> t
val singleton : kind -> Kind.how -> t
val remove : kind -> t -> t
val iter : (kind -> Kind.how -> unit) -> t -> unit
val fold : (kind -> Kind.how -> 'a -> 'a) -> t -> 'a -> 'a
end
val create : string -> Project.t
val register_create_hook : (Project.t -> unit) -> unit
exception NoProject
val current : unit -> Project.t
val is_current : Project.t -> bool
val iter_on_projects : (Project.t -> unit) -> unit
val find_all : string -> Project.t list
val clear_all : unit -> unit
exception IOError of string
val save :
?only:Project.Selection.t ->
?except:Project.Selection.t -> ?project:Project.t -> string -> unit
val load :
?only:Project.Selection.t ->
?except:Project.Selection.t -> name:string -> string -> Project.t
val save_all : string -> unit
val load_all : string -> unit
val register_before_load_hook : (unit -> unit) -> unit
val register_after_load_hook : (unit -> unit) -> unit
val name : Project.t -> string
val unique_name : Project.t -> string
val from_unique_name : string -> Project.t
val set_current :
?on:bool ->
?only:Project.Selection.t ->
?except:Project.Selection.t -> Project.t -> unit
val register_after_set_current_hook :
user_only:bool -> (Project.t -> unit) -> unit
val on :
?only:Project.Selection.t ->
?except:Project.Selection.t -> Project.t -> ('a -> 'b) -> 'a -> 'b
val copy :
?only:Project.Selection.t ->
?except:Project.Selection.t -> ?src:Project.t -> Project.t -> unit
val create_by_copy :
?only:Project.Selection.t ->
?except:Project.Selection.t -> ?src:Project.t -> string -> Project.t
val create_by_copy_hook : (Project.t -> Project.t -> unit) -> unit
val clear :
?only:Project.Selection.t ->
?except:Project.Selection.t -> ?project:Project.t -> unit -> unit
val register_todo_on_clear : (Project.t -> unit) -> unit
exception Cannot_remove of string
val remove : ?project:Project.t -> unit -> unit
val register_before_remove_hook : (Project.t -> unit) -> unit
val compare : Project.t -> Project.t -> int
val equal : Project.t -> Project.t -> bool
val hash : Project.t -> int
val rehash : Project.t -> Project.t
module Undo :
sig
val breakpoint : unit -> unit
val restore : unit -> unit
val clear_breakpoint : unit -> unit
end
end