`sig
module MapPlugin :
sig
type key = OASISTypes.plugin_kind OASISTypes.plugin
type +!'a t
val empty : 'a t
val add : key -> 'a -> 'a t -> 'a t
val add_to_list : key -> 'a -> 'a list t -> 'a list t
val update : key -> ('a option -> 'a option) -> 'a t -> 'a t
val singleton : key -> 'a -> 'a t
val remove : key -> 'a t -> 'a t
val merge :
(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val cardinal : 'a t -> int
val bindings : 'a t -> (key * 'a) list
val min_binding : 'a t -> key * 'a
val min_binding_opt : 'a t -> (key * 'a) option
val max_binding : 'a t -> key * 'a
val max_binding_opt : 'a t -> (key * 'a) option
val choose : 'a t -> key * 'a
val choose_opt : 'a t -> (key * 'a) option
val find : key -> 'a t -> 'a
val find_opt : key -> 'a t -> 'a option
val find_first : (key -> bool) -> 'a t -> key * 'a
val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
val find_last : (key -> bool) -> 'a t -> key * 'a
val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'acc -> 'acc) -> 'a t -> 'acc -> 'acc
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val filter_map : (key -> 'a -> 'b option) -> 'a t -> 'b t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val split : key -> 'a t -> 'a t * 'a option * 'a t
val is_empty : 'a t -> bool
val mem : key -> 'a t -> bool
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val for_all : (key -> 'a -> bool) -> 'a t -> bool
val exists : (key -> 'a -> bool) -> 'a t -> bool
val to_seq : 'a t -> (key * 'a) Seq.t
val to_rev_seq : 'a t -> (key * 'a) Seq.t
val to_seq_from : key -> 'a t -> (key * 'a) Seq.t
val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t
val of_seq : (key * 'a) Seq.t -> 'a t
val add_list : 'a t -> (key * 'a) list -> 'a t
val of_list : (key * 'a) list -> 'a t
val to_list : 'a t -> (key * 'a) list
end
module SetPlugin :
sig
type elt = OASISTypes.plugin_kind OASISTypes.plugin
type t
val empty : t
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 disjoint : t -> t -> bool
val diff : t -> t -> t
val cardinal : t -> int
val elements : t -> elt list
val min_elt : t -> elt
val min_elt_opt : t -> elt option
val max_elt : t -> elt
val max_elt_opt : t -> elt option
val choose : t -> elt
val choose_opt : t -> elt option
val find : elt -> t -> elt
val find_opt : elt -> t -> elt option
val find_first : (elt -> bool) -> t -> elt
val find_first_opt : (elt -> bool) -> t -> elt option
val find_last : (elt -> bool) -> t -> elt
val find_last_opt : (elt -> bool) -> t -> elt option
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'acc -> 'acc) -> t -> 'acc -> 'acc
val map : (elt -> elt) -> t -> t
val filter : (elt -> bool) -> t -> t
val filter_map : (elt -> elt option) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val split : elt -> t -> t * bool * t
val is_empty : t -> bool
val mem : elt -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val subset : t -> t -> bool
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val to_seq_from : elt -> t -> elt Seq.t
val to_seq : t -> elt Seq.t
val to_rev_seq : t -> elt Seq.t
val add_seq : elt Seq.t -> t -> t
val of_seq : elt Seq.t -> t
val add_list : t -> elt list -> t
val of_list : elt list -> t
val to_list : t -> elt list
end
val mem_no_version :
OASISTypes.plugin_kind OASISTypes.plugin ->
OASISPlugin.SetPlugin.t -> bool
type 'a setter = OASISTypes.plugin_data Stdlib.ref -> 'a -> unit
type 'a getter = OASISTypes.plugin_data Stdlib.ref -> 'a
type 'a prop = 'a OASISPlugin.setter * 'a OASISPlugin.getter
type modul = string
type ('a, 'b) setup_changes = {
chng_moduls : OASISPlugin.modul list;
chng_main : 'a OASISDataNotation.func;
chng_clean : 'b OASISDataNotation.func option;
chng_distclean : 'b OASISDataNotation.func option;
}
type context_act = {
ctxt : OASISContext.t;
update : OASISSetupUpdate.t;
error : bool;
files : OASISFileTemplate.templates;
other_actions : (unit -> unit) list;
}
type ('a, 'b) section_act =
OASISPlugin.context_act ->
OASISTypes.package ->
OASISTypes.common_section * 'a ->
OASISPlugin.context_act *
(ctxt:OASISContext.t ->
OASISTypes.package ->
OASISTypes.common_section * 'a -> string array -> 'b,
ctxt:OASISContext.t ->
OASISTypes.package ->
OASISTypes.common_section * 'a -> string array -> unit)
OASISPlugin.setup_changes
type package_act =
OASISPlugin.context_act ->
OASISTypes.package ->
OASISPlugin.context_act *
(ctxt:OASISContext.t -> OASISTypes.package -> string array -> unit,
ctxt:OASISContext.t -> OASISTypes.package -> string array -> unit)
OASISPlugin.setup_changes
type 'a t
type all_t = OASISTypes.plugin_kind OASISPlugin.t
val register_quickstart_completion :
OASISPlugin.all_t -> (OASISTypes.package -> OASISTypes.package) -> unit
val quickstart_completion :
OASISTypes.plugin_kind OASISTypes.plugin ->
OASISTypes.package -> OASISTypes.package
val register_generator_package :
OASISPlugin.all_t ->
'a OASISPlugin.prop -> (PropList.Data.t -> 'a) -> unit
val generator_package :
OASISTypes.plugin_kind OASISTypes.plugin ->
OASISTypes.plugin_data Stdlib.ref -> PropList.Data.t -> unit
val register_generator_section :
OASISTypes.section_kind ->
OASISPlugin.all_t ->
'a OASISPlugin.prop -> (PropList.Data.t -> 'a) -> unit
val generator_section :
OASISTypes.section_kind ->
OASISTypes.plugin_kind OASISTypes.plugin ->
OASISTypes.plugin_data Stdlib.ref -> PropList.Data.t -> unit
val ls : OASISTypes.plugin_kind -> OASISTypes.name list
val all_plugins : unit -> OASISTypes.plugin_kind OASISTypes.plugin list
type help = { help_template : string list; help_order : int; }
val help_default : string list -> OASISPlugin.help
val register_help :
[ `All | `Build | `Configure | `Doc | `Extra | `Install | `Test ]
OASISTypes.plugin -> OASISPlugin.help -> unit
val help : [ `All ] OASISTypes.plugin -> OASISPlugin.help
val to_plugin : 'a OASISPlugin.t -> 'a OASISTypes.plugin
module type PLUGINS =
sig
type data
type act
type kind
type self_t = OASISPlugin.PLUGINS.kind OASISPlugin.t
type self_plugin = OASISPlugin.PLUGINS.kind OASISTypes.plugin
val create :
OASISPlugin.PLUGINS.self_plugin ->
OASISPlugin.PLUGINS.self_t * OASISPlugin.all_t
val register_act :
OASISPlugin.PLUGINS.self_t -> OASISPlugin.PLUGINS.act -> unit
val act : OASISPlugin.PLUGINS.self_plugin -> OASISPlugin.PLUGINS.act
val quickstart_question :
unit ->
OASISPlugin.PLUGINS.self_plugin OASISTypes.quickstart_question
val value : OASISPlugin.PLUGINS.self_plugin OASISValues.t
end
module Configure :
sig
type data = OASISTypes.package
type act = package_act
type kind = [ `Configure ]
type self_t = kind t
type self_plugin = kind OASISTypes.plugin
val create : self_plugin -> self_t * all_t
val register_act : self_t -> act -> unit
val act : self_plugin -> act
val quickstart_question :
unit -> self_plugin OASISTypes.quickstart_question
val value : self_plugin OASISValues.t
end
module Build :
sig
type data = OASISTypes.package
type act = package_act
type kind = [ `Build ]
type self_t = kind t
type self_plugin = kind OASISTypes.plugin
val create : self_plugin -> self_t * all_t
val register_act : self_t -> act -> unit
val act : self_plugin -> act
val quickstart_question :
unit -> self_plugin OASISTypes.quickstart_question
val value : self_plugin OASISValues.t
end
module Doc :
sig
type data = OASISTypes.common_section * OASISTypes.doc
type act = (OASISTypes.doc, unit) section_act
type kind = [ `Doc ]
type self_t = kind t
type self_plugin = kind OASISTypes.plugin
val create : self_plugin -> self_t * all_t
val register_act : self_t -> act -> unit
val act : self_plugin -> act
val quickstart_question :
unit -> self_plugin OASISTypes.quickstart_question
val value : self_plugin OASISValues.t
end
module Test :
sig
type data = OASISTypes.common_section * OASISTypes.test
type act = (OASISTypes.test, float) section_act
type kind = [ `Test ]
type self_t = kind t
type self_plugin = kind OASISTypes.plugin
val create : self_plugin -> self_t * all_t
val register_act : self_t -> act -> unit
val act : self_plugin -> act
val quickstart_question :
unit -> self_plugin OASISTypes.quickstart_question
val value : self_plugin OASISValues.t
end
module Install :
sig
type data = OASISTypes.package
type act = package_act * package_act
type kind = [ `Install ]
type self_t = kind t
type self_plugin = kind OASISTypes.plugin
val create : self_plugin -> self_t * all_t
val register_act : self_t -> act -> unit
val act : self_plugin -> act
val quickstart_question :
unit -> self_plugin OASISTypes.quickstart_question
val value : self_plugin OASISValues.t
end
module Extra :
sig
type data = OASISTypes.package
type act = context_act -> OASISTypes.package -> context_act
type kind = [ `Extra ]
type self_t = kind t
type self_plugin = kind OASISTypes.plugin
val create : self_plugin -> self_t * all_t
val register_act : self_t -> act -> unit
val act : self_plugin -> act
val quickstart_question :
unit -> self_plugin OASISTypes.quickstart_question
val value : self_plugin OASISValues.t
end
val test_field_name : string -> bool
val builtin : 'a -> OASISTypes.name -> 'a OASISTypes.plugin
val add_file :
OASISFileTemplate.template ->
OASISPlugin.context_act -> OASISPlugin.context_act
val set_error :
bool -> string -> OASISPlugin.context_act -> OASISPlugin.context_act
val plugin_of_string : 'a -> string -> 'a OASISTypes.plugin
val plugins_of_string : 'a -> string -> 'a OASISTypes.plugin list
val string_of_plugin : 'a OASISTypes.plugin -> string
val plugin_compare : 'a OASISTypes.plugin -> 'a OASISTypes.plugin -> int
val plugin_equal : 'a OASISTypes.plugin -> 'a OASISTypes.plugin -> bool
val data_create : unit -> OASISTypes.plugin_data Stdlib.ref
val data_new_property :
?purpose:OASISTypes.plugin_data_purpose ->
OASISTypes.plugin_kind OASISTypes.plugin -> 'a OASISPlugin.prop
end`