module type GraphType =
sig
(* Abstract type for vertices *)
  type vertex

(* Graph type *)
  type t

(* make order : build a Graph with order vertices *)
  val make : int -> t

(* order g : returns the number of vertices in g *)
val order : t -> int

(* get_vertex g id : retrieve vertex *)
  val get_vertex : t -> int -> vertex

(* get_id v : returns vertex id *)
val get_id : vertex -> int

(* add_edge g src dst cost : add an edge (src -> dst) with cost *)
  val add_edge : t -> int -> int -> float -> unit

(* iter_successor g f v : apply function f on all successor of v *)
  val iter_successor : t -> (vertex -> float -> unit) -> vertex -> unit

(* iter_predecessor g f v : apply function f on all predecessor of v *)
  val iter_predecessor : t -> (vertex -> float -> unit) -> vertex -> unit
end

module Builder (G: GraphType) =
struct
  let kw = ["digraph"; "{"; "}"; ";"; "->"; "order"; "="; "cost"; "["; "]"]

  let parse_edge g =
    parser
      [<
        'Genlex.Int src; 'Genlex.Kwd "->"; 'Genlex.Int dst;
        'Genlex.Kwd "[" ;
        'Genlex.Kwd "cost" ; 'Genlex.Kwd "=" ; 'Genlex.Float cost;
        'Genlex.Kwd "]"; 'Genlex.Kwd ";";
      >] -> G.add_edge g src dst cost

  let rec parse_edges_list g =
    parser
    | [< _ = parse_edge g; _ = parse_edges_list g;>] -> ()
    | [<>] -> ()

  let parse_header =
    parser
      [<
        'Genlex.Kwd "digraph"; 'Genlex.Kwd "{";
        'Genlex.Kwd "order"; 'Genlex.Kwd "=";
        'Genlex.Int order; 'Genlex.Kwd ";";
      >] -> G.make order

  let parse_graph =
    parser
      [<
        g = parse_header;
        _ = parse_edges_list g;
        'Genlex.Kwd "}";
      >] -> g

  let load file =
    let cin = open_in file in
    let lex = Genlex.make_lexer kw (Stream.of_channel cin) in
    let g = parse_graph lex in
    close_in cin; g

end