1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
|
val debug_flag : bool ref
val with_defs : bool ref
val reduce_trans : bool ref
val pp : string -> ('a, Format.formatter, unit) format -> 'a
val debug : ('a, Format.formatter, unit) format -> 'a
val error : ('a, Format.formatter, unit) format -> 'a
val warning : ('a, Format.formatter, unit) format -> 'a
val feedback : ('a, Format.formatter, unit) format -> 'a
type error =
OpenFileError of string
| LexicalError of Lexing.position * string
| UnterminatedComment of Lexing.position option
| ParsingError of Lexing.position * Lexing.position
| EdgeWithoutNode of int
| NodeWithSameId of int * string * string
exception Error of error
val pp_lex_pos : Format.formatter -> Lexing.position -> unit
val pp_lex_inter :
Format.formatter -> Lexing.position * Lexing.position -> unit
val pp_error : error -> unit
val get_attrib : 'a -> ('a * 'b) list -> 'b option
val bool_attrib : 'a -> ('a * string) list -> bool option
module Node :
sig
type t = int * string * (string * string) list
val id : 'a * 'b * 'c -> 'a
val name : 'a * 'b * 'c -> 'b
val attribs : 'a * 'b * 'c -> 'c
val get_attrib : 'a -> 'b * 'c * ('a * 'd) list -> 'd option
val bool_attrib : 'a -> 'b * 'c * ('a * string) list -> bool option
val hash : 'a * 'b * 'c -> 'a
val equal : 'a * 'b * 'c -> 'a * 'd * 'e -> bool
val compare : 'a * 'b * 'c -> 'a * 'd * 'e -> int
end
module Edge :
sig
type t = (string * string) list
val get_attrib : 'a -> ('a * 'b) list -> 'b option
val bool_attrib : 'a -> ('a * string) list -> bool option
val compare : 'a -> 'a -> int
val default : 'a list
end
module G :
sig
type t = Graph.Imperative.Digraph.ConcreteLabeled(Node)(Edge).t
module V :
sig
type t = Node.t
val compare : t -> t -> int
val hash : t -> int
val equal : t -> t -> bool
type label = Node.t
val create : label -> t
val label : t -> label
end
type vertex = V.t
module E :
sig
type t = Node.t * Edge.t * Node.t
val compare : t -> t -> int
type vertex = V.t
val src : t -> vertex
val dst : t -> vertex
type label = Edge.t
val create : vertex -> label -> vertex -> t
val label : t -> label
end
type edge = E.t
val is_directed : bool
val is_empty : t -> bool
val nb_vertex : t -> int
val nb_edges : t -> int
val out_degree : t -> vertex -> int
val in_degree : t -> vertex -> int
val mem_vertex : t -> vertex -> bool
val mem_edge : t -> vertex -> vertex -> bool
val mem_edge_e : t -> edge -> bool
val find_edge : t -> vertex -> vertex -> edge
val find_all_edges : t -> vertex -> vertex -> edge list
val succ : t -> vertex -> vertex list
val pred : t -> vertex -> vertex list
val succ_e : t -> vertex -> edge list
val pred_e : t -> vertex -> edge list
val iter_vertex : (vertex -> unit) -> t -> unit
val fold_vertex : (vertex -> 'a -> 'a) -> t -> 'a -> 'a
val iter_edges : (vertex -> vertex -> unit) -> t -> unit
val fold_edges : (vertex -> vertex -> 'a -> 'a) -> t -> 'a -> 'a
val iter_edges_e : (edge -> unit) -> t -> unit
val fold_edges_e : (edge -> 'a -> 'a) -> t -> 'a -> 'a
val map_vertex : (vertex -> vertex) -> t -> t
val iter_succ : (vertex -> unit) -> t -> vertex -> unit
val iter_pred : (vertex -> unit) -> t -> vertex -> unit
val fold_succ : (vertex -> 'a -> 'a) -> t -> vertex -> 'a -> 'a
val fold_pred : (vertex -> 'a -> 'a) -> t -> vertex -> 'a -> 'a
val iter_succ_e : (edge -> unit) -> t -> vertex -> unit
val fold_succ_e : (edge -> 'a -> 'a) -> t -> vertex -> 'a -> 'a
val iter_pred_e : (edge -> unit) -> t -> vertex -> unit
val fold_pred_e : (edge -> 'a -> 'a) -> t -> vertex -> 'a -> 'a
val create : ?size:int -> unit -> t
val clear : t -> unit
val copy : t -> t
val add_vertex : t -> vertex -> unit
val remove_vertex : t -> vertex -> unit
val add_edge : t -> vertex -> vertex -> unit
val add_edge_e : t -> edge -> unit
val remove_edge : t -> vertex -> vertex -> unit
val remove_edge_e : t -> edge -> unit
end
type t_obj = N of Node.t | E of (int * int * (string * string) list)
val build_graph : t_obj list -> G.t
val reduce_graph : G.t -> unit
val remove_node : G.t -> G.vertex -> unit
val remove_some_nodes : G.t -> unit
val simplify_graph : G.t -> unit
|
