(* 
 * 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
