Previous  Up  

Functor Suffix_tree.Make

module Make: 
functor (Param : PARAM) -> sig .. end
Parameters:
Param : PARAM 
type strid = int 
type node = {
   mutable seqid : strid;
   mutable start : int;
   mutable final : int Pervasives.ref;
   mutable parent : node;
   v : node_value;
} 
type node_value =
| I of node_internal
| L of int 
type node_internal = {
   children : (char, node) Hashtbl.t;
   mutable link : node;
   mutable backlinks : node Lset.t;
   mutable ext : Suffix_tree.Ext.t;
   mutable locals : Suffix_tree.Ext.t;
   mutable maximal_right : bool;
   mutable maximal : int;
   mutable visible : int * int;
} 
type factor = node * string * node 
type t = {
   mutable cpt : strid;
   ht : (strid, string) Hashtbl.t;
   mutable root : node;
} 
val get0 : t -> strid -> string
val ext0 : node -> Suffix_tree.Ext.t
val maximal0 : node -> int
val locals0 : node -> Suffix_tree.Ext.t
val size : t -> strid
val is_root : t -> node * ('a * 'b * int) * 'c -> bool
val root : t -> node
val is_leaf : 'a -> node -> bool
val length : 'a -> node -> int
val label : t -> node -> string
val ext : 'a -> node -> strid Lset.t
val card : 'a -> node -> int
val is_maximal : 'a -> node -> bool
val children : 'a -> node -> node list
val parent : t -> node -> node option
val succ : t -> node -> node option
val preds : 'a -> node -> node Lset.t
val suffix : 'a -> node -> strid * int
val path : t -> node -> string
val height : t -> node -> int
val set_visible : 'a -> node -> int * int -> unit
val get_visible : 'a -> node -> int * int
val reduce : t ->
       node -> int * int -> node * int
val reduce_left : t -> int -> node -> node
val reduce_right : t ->
       int -> node -> node * int
val eq_char : char -> char -> bool
val get_child : node * (string * int * int) -> node
val canonical : node * (string * int * int) * node ->
       node * (string * int * int) * node
val is_root : t -> node * ('a * 'b * int) * 'c -> bool
val has_child : t ->
       node * (string * int * int) * node ->
       strid * int ->
       (node * (string * int * int) * node) option
val has_end : t ->
       node * string * node ->
       node list option
val add_leaf : t ->
       node ->
       strid -> int -> int Pervasives.ref -> int -> unit
val insert_node : t ->
       int ->
       node * ('a * 'b * int) * node ->
       node
val add_strid : t -> int -> node -> unit
val add_link : int -> node option -> node -> unit
val get_link : t ->
       node * (string * int * int) * 'a ->
       node * (string * int * int) * node
type res = {
   terminal : int Pervasives.ref;
   mutable startj : int;
   mutable startnode : node * Suffix_tree.Subseq.t * node;
} 
val update : t ->
       strid * int ->
       res -> node option -> unit
val create : unit -> t
val fold_tree : t ->
       ('h -> node -> bool) ->
       ('h -> node -> 'h) ->
       ('s list -> 'h -> node -> 's) -> 'h -> 's
val fold_node : t ->
       ('h -> node -> bool) ->
       ('h -> node -> 'h) ->
       ('s list -> 'h -> node -> 's) ->
       'h -> node -> 's
val fold_s_node : t ->
       ('a list -> node -> 'a) -> node -> 'a
val fold_s_tree : t -> ('a list -> node -> 'a) -> 'a
val fold_fs_node : t ->
       (node -> bool) ->
       ('a list -> node -> 'a) -> node -> 'a
val fold_fs_tree : t ->
       (node -> bool) ->
       ('a list -> node -> 'a) -> 'a
val path_restrictions : t -> node -> node list
val path_extensions : 'a -> node -> node list
val max_restrictions : t -> node -> node list
val max_restrictions_aux : t ->
       (int * node) list ->
       node list -> (int * node) list
module SetShiftNode: Set.Make(sig


type t = Suffix_tree.Make.node 




val compare : 'a -> 'a -> int
end)
val max_extensions : t ->
       SetShiftNode.elt option ->
       SetShiftNode.elt list * int list
val max_extensions_right : t ->
       bool ->
       bool ->
       int * int ->
       SetShiftNode.elt ->
       SetShiftNode.t -> SetShiftNode.t
val max_extensions_left : t ->
       bool ->
       int * int ->
       SetShiftNode.elt ->
       SetShiftNode.t -> SetShiftNode.t
val max_extensions_remove_right : t ->
       bool ->
       bool ->
       SetShiftNode.elt ->
       SetShiftNode.t -> SetShiftNode.t
val max_extensions_remove_left : t ->
       bool ->
       SetShiftNode.elt ->
       SetShiftNode.t -> SetShiftNode.t
val string_restrictions : t -> int -> node list
val find_factor : t ->
       string -> node * string * node
val find_factor_aux : t ->
       node ->
       string * int * int ->
       node * (string * int * int) * node
val suffixes : t ->
       'a * 'b * node -> (strid * int) list
val strings : 'a -> 'b * 'c * node -> strid Lset.t
val get : t -> strid -> string
val find : t -> string -> strid
val find_node : t -> string -> node
val add : t -> string -> strid
val remove : t -> strid -> unit
val remove_node : bool ->
       t ->
       strid ->
       node -> (node * Suffix_tree.Ext.t) option
val remove_link : t -> node -> unit
val remove_maxcard : (char * node * Suffix_tree.Ext.t) list ->
       node Lset.t -> int * int
val fold : (strid -> string -> 'a -> 'a) ->
       t -> 'a -> 'a
type tree =
| Node of string * int * int list * tree list
| Leaf of string * (strid * int) 
val tree : t -> tree