Note:

You are viewing a development version of the library. Goto the latest version.

sig
  module MapPlugin :
    sig
      type key = OASISTypes.plugin_kind OASISTypes.plugin
      type +'a t
      val empty : 'a t
      val is_empty : 'a t -> bool
      val mem : key -> 'a t -> bool
      val add : key -> '-> 'a t -> 'a t
      val singleton : key -> '-> '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 compare : ('-> '-> int) -> 'a t -> 'a t -> int
      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
      val iter : (key -> '-> unit) -> 'a t -> unit
      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
      val for_all : (key -> '-> bool) -> 'a t -> bool
      val exists : (key -> '-> bool) -> 'a t -> bool
      val filter : (key -> '-> bool) -> 'a t -> 'a t
      val partition : (key -> '-> bool) -> '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 max_binding : 'a t -> key * 'a
      val choose : 'a t -> key * 'a
      val split : key -> 'a t -> 'a t * 'a option * 'a t
      val find : key -> 'a t -> 'a
      val map : ('-> 'b) -> 'a t -> 'b t
      val mapi : (key -> '-> 'b) -> 'a t -> 'b 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 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) -> t -> '-> '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 find : elt -> t -> elt
      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 Pervasives.ref -> '-> unit
  type 'a getter = OASISTypes.plugin_data Pervasives.ref -> 'a
  type 'a prop = 'OASISPlugin.setter * 'OASISPlugin.getter
  type modul = string
  type ('a, 'b) setup_changes = {
    chng_moduls : OASISPlugin.modul list;
    chng_main : 'ODNFunc.func;
    chng_clean : 'ODNFunc.func option;
    chng_distclean : 'ODNFunc.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 * '->
      OASISPlugin.context_act *
      (OASISTypes.package ->
       OASISTypes.common_section * '-> string array -> 'b,
       OASISTypes.package ->
       OASISTypes.common_section * '-> string array -> unit)
      OASISPlugin.setup_changes
  type package_act =
      OASISPlugin.context_act ->
      OASISTypes.package ->
      OASISPlugin.context_act *
      (OASISTypes.package -> string array -> unit,
       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 ->
    'OASISPlugin.prop -> (PropList.Data.t -> 'a) -> unit
  val generator_package :
    OASISTypes.plugin_kind OASISTypes.plugin ->
    OASISTypes.plugin_data Pervasives.ref -> PropList.Data.t -> unit
  val register_generator_section :
    OASISTypes.section_kind ->
    OASISPlugin.all_t ->
    'OASISPlugin.prop -> (PropList.Data.t -> 'a) -> unit
  val generator_section :
    OASISTypes.section_kind ->
    OASISTypes.plugin_kind OASISTypes.plugin ->
    OASISTypes.plugin_data Pervasives.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 : 'OASISPlugin.t -> '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 : '-> OASISTypes.name -> '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 : '-> string -> 'OASISTypes.plugin
  val plugins_of_string : '-> string -> 'OASISTypes.plugin list
  val string_of_plugin : 'OASISTypes.plugin -> string
  val plugin_compare : 'OASISTypes.plugin -> 'OASISTypes.plugin -> int
  val plugin_equal : 'OASISTypes.plugin -> 'OASISTypes.plugin -> bool
  val data_create : unit -> OASISTypes.plugin_data Pervasives.ref
  val data_new_property :
    ?purpose:OASISTypes.plugin_data_purpose ->
    OASISTypes.plugin_kind OASISTypes.plugin -> 'OASISPlugin.prop
end