(*
* ExtHashtbl - extra functions over hashtables.
* Copyright (C) 2003 Nicolas Cannasse
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version,
* with the special exception on linking described in file LICENSE.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*)
(** Extra functions over hashtables. *)
module Hashtbl :
(** The wrapper module *)
sig
type ('a,'b) t = ('a,'b) Hashtbl.t
(** The type of a hashtable. *)
(** {6 New Functions} *)
val exists : ('a,'b) t -> 'a -> bool
(** [exists h k] returns true is at least one item with key [k] is
found in the hashtable. *)
val keys : ('a,'b) t -> 'a Enum.t
(** Return an enumeration of all the keys of a hashtable.
If the key is in the Hashtable multiple times, all occurrences
will be returned. *)
val values : ('a,'b) t -> 'b Enum.t
(** Return an enumeration of all the values of a hashtable. *)
val enum : ('a, 'b) t -> ('a * 'b) Enum.t
(** Return an enumeration of (key,value) pairs of a hashtable. *)
val of_enum : ('a * 'b) Enum.t -> ('a, 'b) t
(** Create a hashtable from a (key,value) enumeration. *)
val find_default : ('a,'b) t -> 'a -> 'b -> 'b
(** Find a binding for the key, and return a default
value if not found *)
val find_opt : ('a,'b) Hashtbl.t -> 'a -> 'b option
(** Find a binding for the key, or return [None] if no
value is found *)
val find_option : ('a,'b) Hashtbl.t -> 'a -> 'b option
(** compatibility, use [find_opt] *)
val remove_all : ('a,'b) t -> 'a -> unit
(** Remove all bindings for the given key *)
val map : ('b -> 'c) -> ('a,'b) t -> ('a,'c) t
(** [map f x] creates a new hashtable with the same
keys as [x], but with the function [f] applied to
all the values *)
val length : ('a,'b) t -> int
(** Return the number of elements inserted into the Hashtbl
(including duplicates) *)
#if OCAML >= 400
val reset : ('a,'b) t -> unit
val randomize : unit -> unit
type statistics = Hashtbl.statistics = {
num_bindings: int;
num_buckets: int;
max_bucket_length: int;
bucket_histogram: int array;
}
val stats : ('a,'b) t -> statistics
val seeded_hash_param : int -> int -> int -> 'a -> int
val seeded_hash : int -> 'a -> int
#endif
#if OCAML >= 403
val is_randomized : unit -> bool
val filter_map_inplace : ('a -> 'b -> 'b option) -> ('a, 'b) t -> unit
#endif
(** {6 Older Functions} *)
(** Please refer to the Ocaml Manual for documentation of these
functions. *)
(** @before 4.00.0 [random] is ignored *)
val create : ?random:bool -> int -> ('a, 'b) t
val clear : ('a, 'b) t -> unit
val add : ('a, 'b) t -> 'a -> 'b -> unit
val copy : ('a, 'b) t -> ('a, 'b) t
val find : ('a, 'b) t -> 'a -> 'b
val find_all : ('a, 'b) t -> 'a -> 'b list
val mem : ('a, 'b) t -> 'a -> bool
val remove : ('a, 'b) t -> 'a -> unit
val replace : ('a, 'b) t -> 'a -> 'b -> unit
val iter : ('a -> 'b -> unit) -> ('a, 'b) t -> unit
val fold : ('a -> 'b -> 'c -> 'c) -> ('a, 'b) t -> 'c -> 'c
val hash : 'a -> int
val hash_param : int -> int -> 'a -> int
#if OCAML >= 407
(** [*_seq] functions were introduced in OCaml 4.07.0, and are _not_ implemented in extlib for older OCaml versions *)
val to_seq : ('a,'b) t -> ('a * 'b) Seq.t
val to_seq_keys : ('a,_) t -> 'a Seq.t
val to_seq_values : (_,'b) t -> 'b Seq.t
val add_seq : ('a,'b) t -> ('a * 'b) Seq.t -> unit
val replace_seq : ('a,'b) t -> ('a * 'b) Seq.t -> unit
val of_seq : ('a * 'b) Seq.t -> ('a, 'b) t
#endif
(** Functor interface forwards directly to stdlib implementation (i.e. no enum functions) *)
#if OCAML >= 407
module type HashedType = Hashtbl.HashedType
module type S = Hashtbl.S
module Make = Hashtbl.Make
module type SeededHashedType = Hashtbl.SeededHashedType
module type SeededS = Hashtbl.SeededS
module MakeSeeded = Hashtbl.MakeSeeded
#else
module type HashedType =
sig
type t
val equal : t -> t -> bool
val hash : t -> int
end
module type S =
sig
type key
type 'a t
val create : int -> 'a t
val clear : 'a t -> unit
#if OCAML >= 400
val reset : 'a t -> unit
#endif
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
#if OCAML >= 405
val find_opt : 'a t -> key -> 'a option
#endif
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
#if OCAML >= 403
val filter_map_inplace: (key -> 'a -> 'a option) -> 'a t -> unit
#endif
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
#if OCAML >= 400
val stats: 'a t -> statistics
#endif
end
module Make (H : HashedType) : S with type key = H.t
#if OCAML >= 400
module type SeededHashedType =
sig
type t
val equal: t -> t -> bool
val hash: int -> t -> int
end
module type SeededS =
sig
type key
type 'a t
val create : ?random:bool -> int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
#if OCAML >= 405
val find_opt : 'a t -> key -> 'a option
#endif
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
#if OCAML >= 403
val filter_map_inplace: (key -> 'a -> 'a option) -> 'a t -> unit
#endif
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats: 'a t -> statistics
end
module MakeSeeded (H : SeededHashedType) : SeededS with type key = H.t
#endif
#endif
end