1.1 --- a/doc/Doxyfile Fri Mar 19 07:39:09 2004 +0000
1.2 +++ b/doc/Doxyfile Fri Mar 19 07:40:00 2004 +0000
1.3 @@ -60,7 +60,8 @@
1.4 INPUT = ../src/demo/alpar/emptygraph.h \
1.5 ../src/doxy/invalid.h \
1.6 ../src/demo/alpar/smart_graph.h \
1.7 - ../src/demo/alpar/mapskeleton.h
1.8 + ../src/demo/alpar/mapskeleton.h \
1.9 + maps.dox
1.10 FILE_PATTERNS =
1.11 RECURSIVE = NO
1.12 EXCLUDE =
2.1 --- a/doc/flf-graph.texi Fri Mar 19 07:39:09 2004 +0000
2.2 +++ b/doc/flf-graph.texi Fri Mar 19 07:40:00 2004 +0000
2.3 @@ -21,14 +21,14 @@
2.4
2.5 @subsection Types
2.6
2.7 -@deftp {Type} Graph::NodeType
2.8 -@deftpx {Type} Graph::EdgeType
2.9 -The type of the data stored statically for each node and edge.
2.10 -@end deftp
2.11 +@c @deftp {Type} Graph::NodeType
2.12 +@c @deftpx {Type} Graph::EdgeType
2.13 +@c The type of the data stored statically for each node and edge.
2.14 +@c @end deftp
2.15
2.16 @anchor{Graph-NodeIterator}
2.17 @deftp {Type} Graph::NodeIt
2.18 -@deftpx {Type} Graph::NodeIterator
2.19 +@c @deftpx {Type} Graph::NodeIterator
2.20 These types points a node uniquely. The difference between the
2.21 @code{NodeIt} and the @code{NodeIterator} is that @code{NodeIt}
2.22 requires the graph structure itself for most of the operations.
2.23 @@ -58,8 +58,9 @@
2.24 @deftp {Type} Graph::EdgeIt
2.25 @deftpx {Type} Graph::InEdgeIt
2.26 @deftpx {Type} Graph::OutEdgeIt
2.27 -@deftpx {Type} Graph::BiEdgeIt
2.28 -@deftpx {Type} Graph::SymEdgeIt
2.29 +@deftpx {Type} Graph::EachEdgeIt
2.30 +@c @deftpx {Type} Graph::BiEdgeIt
2.31 +@c @deftpx {Type} Graph::SymEdgeIt
2.32 Each of these types points an edge uniquely. The difference between the
2.33 @code{EdgeIt} and the
2.34 @c @mref{Graph-NodeIterator,@code{EdgeIterator}}
2.35 @@ -70,98 +71,106 @@
2.36 @end deftp
2.37
2.38 @anchor{Graph-EdgeIterator}
2.39 -@deftp {Type} Graph::EdgeIterator
2.40 -@deftpx {Type} Graph::InEdgeIterator
2.41 -@deftpx {Type} Graph::OutEdgeIterator
2.42 -@deftpx {Type} Graph::BiEdgeIterator
2.43 -@deftpx {Type} Graph::SymEdgeIterator
2.44 -@deftpx {Type} Graph::EachEdgeIterator
2.45 -Each of these types points an edge uniquely. The difference between the
2.46 -@code{EdgeIt} and the @code{EdgeIterator} series is that
2.47 -@code{EdgeIt} requires the graph structure itself for most of the
2.48 -operations.
2.49 +@c @deftp {Type} Graph::EdgeIterator
2.50 +@c @deftpx {Type} Graph::InEdgeIterator
2.51 +@c @deftpx {Type} Graph::OutEdgeIterator
2.52 +@c @deftpx {Type} Graph::BiEdgeIterator
2.53 +@c @deftpx {Type} Graph::SymEdgeIterator
2.54 +@c @deftpx {Type} Graph::EachEdgeIterator
2.55 +@c Each of these types points an edge uniquely. The difference between the
2.56 +@c @code{EdgeIt} and the @code{EdgeIterator} series is that
2.57 +@c @code{EdgeIt} requires the graph structure itself for most of the
2.58 +@c operations.
2.59
2.60 -For the @code{EdgeIterator} types you can use operator @code{++}
2.61 -(both the prefix and the posfix one) to obtain the next edge.
2.62 -@end deftp
2.63 +@c For the @code{EdgeIterator} types you can use operator @code{++}
2.64 +@c (both the prefix and the posfix one) to obtain the next edge.
2.65 +@c @end deftp
2.66
2.67 -@deftp {Type} Graph::NodeMap
2.68 -@deftpx {Type} Graph::EdgeMap
2.69 +@deftp {Type} Graph::NodeMap<typename T>
2.70 +@deftpx {Type} Graph::EdgeMap<typename T>
2.71 There are the default property maps for the edges and the nodes.
2.72 @end deftp
2.73
2.74 +@deftp {Type} Graph::DynNodeMap<typename T>
2.75 +@deftpx {Type} Graph::DynEdgeMap<typename T>
2.76 +There are the default @emph{dynamic} property maps for the edges and the nodes.
2.77 +@end deftp
2.78
2.79 @subsection Member Functions
2.80
2.81 @subsubsection Constructors
2.82
2.83 -
2.84 @deftypefun { } Graph::Graph ()
2.85 The default constructor.
2.86 @end deftypefun
2.87
2.88 @c @deftypefun { } Graph::Graph (Graph@tie{}&)
2.89 @deftypefun { } Graph::Graph (Graph &)
2.90 -The copy constructor. Not yet implemented.
2.91 +The copy constructor.
2.92 @end deftypefun
2.93
2.94 @subsubsection Graph Maintenence Operations
2.95
2.96 -@deftypefun NodeIterator Graph::addNode ()
2.97 -Adds a new node to the graph and returns a @code{NodeIterator} pointing to it.
2.98 +@deftypefun NodeIt Graph::addNode ()
2.99 +Adds a new node to the graph and returns a @code{NodeIt} pointing to it.
2.100 @end deftypefun
2.101
2.102 -@deftypefun EdgeIterator Graph::addEdge (@w{const @mref{Graph-NodeIterator,NodeIterator} @var{from}}, @w{const @mref{Graph-NodeIterator,NodeIterator} @var{to}})
2.103 +@deftypefun EdgeIt Graph::addEdge (@w{const @mref{Graph-NodeIterator,NodeIt} @var{from}}, @w{const @mref{Graph-NodeIterator,NodeIt} @var{to}})
2.104 Adds a new edge with tail @var{from} and head @var{to} to the graph
2.105 -and returns an @code{EdgeIterator} pointing to it.
2.106 +and returns an @code{EdgeIt} pointing to it.
2.107 @end deftypefun
2.108
2.109 -@deftypefun void Graph::delete (@w{const @mref{Graph-NodeIterator,NodeIterator} @var{n}})
2.110 +@deftypefun void Graph::delete (@w{const @mref{Graph-NodeIterator,NodeIt} @var{n}})
2.111 Deletes the node @var{n}. It also deletes the adjacent edges.
2.112 @end deftypefun
2.113
2.114 -@deftypefun void Graph::delete (@w{const @mref{Graph-EdgeIterator,EdgeIterator} @var{e}})
2.115 +@deftypefun void Graph::delete (@w{const @mref{Graph-EdgeIterator,EdgeIt} @var{e}})
2.116 Deletes the edge @var{n}.
2.117 @end deftypefun
2.118
2.119 -@deftypefun void Graph::clean ()
2.120 +@deftypefun void Graph::clear ()
2.121 Deletes all edges and nodes from the graph.
2.122 @end deftypefun
2.123
2.124 @deftypefun int Graph::nodeNum ()
2.125 Returns the number of the nodes in the graph.
2.126 +??? Is it necessary???
2.127 @end deftypefun
2.128
2.129 @subsubsection NodeIt Operations
2.130
2.131 -@deftypefun NodeIt Graph::getFirst (NodeIt &@var{n})
2.132 -@deftypefunx NodeIt Graph::next (const NodeIt @var{n})
2.133 -@deftypefunx {NodeIt &} Graph::goNext (NodeIt &@var{n})
2.134 -The nodes in the graph forms a list. @code{GetFirst(n)} sets @var{n} to
2.135 -be the first node. @code{next(n)} gives back the subsequent
2.136 -node. @code{Next(n)} is equivalent to @code{n=Next(n)}, though it
2.137 +@deftypefun NodeIt Graph::getFirst (NodeIt &@var{n}) const
2.138 +@deftypefunx NodeIt Graph::getNext (NodeIt @var{n}) const
2.139 +@deftypefunx {NodeIt &} Graph::next (NodeIt &@var{n})
2.140 +The nodes in the graph forms a list. @code{getFirst(n)} sets @var{n} to
2.141 +be the first node. @code{getNext(n)} gives back the subsequent
2.142 +node. @code{next(n)} is equivalent to @code{n=getNext(n)}, though it
2.143 might be faster. ??? What should be the return value ???
2.144 @end deftypefun
2.145
2.146 @deftypefun bool Graph::valid (NodeIt &@var{e})
2.147 -@deftypefunx bool NodeIt::valid ()
2.148 +@c @deftypefunx bool NodeIt::valid ()
2.149 These functions check if and NodeIt is valid or not.
2.150 -??? Which one should be implemented ???
2.151 +@c ??? Which one should be implemented ???
2.152 @end deftypefun
2.153
2.154 @subsubsection EdgeIt Operations
2.155
2.156 -@deftypefun EachEdgeIt Graph::getFirst (const EachEdgeIt & @var{e})
2.157 -@deftypefunx EachEdgeIt Graph::next (const EachEdgeIt @var{n})
2.158 -@deftypefunx {EachEdgeIt &} Graph::goNext (EachEdgeIt &@var{n})
2.159 +@deftypefun EachEdgeIt Graph::getFirst (const EachEdgeIt & @var{e}) const
2.160 +@deftypefunx EachEdgeIt Graph::getNext (EachEdgeIt @var{n}) const
2.161 +@deftypefunx {EachEdgeIt &} Graph::next (EachEdgeIt &@var{n})
2.162 With these functions you can go though all the edges of the graph.
2.163 -??? What should be the return value ???
2.164 +@c ??? What should be the return value ???
2.165 @end deftypefun
2.166
2.167 -@deftypefun InEdgeIt Graph::getFirst (const InEdgeIt & @var{e}, const NodeIt @var{n})
2.168 -@deftypefunx OutEdgeIt Graph::getFirst (const OutEdgeIt & @var{e}, const NodeIt @var{n})
2.169 -@deftypefunx SymEdgeIt Graph::getFirst (const SymEdgeIt & @var{e}, const NodeIt @var{n})
2.170 -The edges leaving from, arriving at or adjacent with a node forms a
2.171 +@deftypefun InEdgeIt &Graph::getFirst (InEdgeIt & @var{e}, const NodeIt @var{n})
2.172 +@deftypefunx OutEdgeIt &Graph::getFirst (OutEdgeIt & @var{e}, const NodeIt @var{n})
2.173 +@c @deftypefunx SymEdgeIt &Graph::getFirst (SymEdgeIt & @var{e}, const NodeIt @var{n})
2.174 +The edges leaving from
2.175 +or
2.176 +arriving at
2.177 +@c or adjacent with
2.178 +a node forms a
2.179 list. These functions give back the first elements of these
2.180 lists. The exact behavior depends on the type of @var{e}.
2.181
2.182 @@ -169,9 +178,9 @@
2.183 @code{getFirst} sets @var{e} to be the first incoming or outgoing edge
2.184 of the node @var{n}, respectively.
2.185
2.186 -If @var{e} is a @code{SymEdgeIt} then
2.187 -@code{getFirst} sets @var{e} to be the first incoming if there exists one
2.188 -otherwise the first outgoing edge.
2.189 +@c If @var{e} is a @code{SymEdgeIt} then
2.190 +@c @code{getFirst} sets @var{e} to be the first incoming if there exists one
2.191 +@c otherwise the first outgoing edge.
2.192
2.193 If there are no such edges, @var{e} will be invalid.
2.194
2.195 @@ -218,7 +227,12 @@
2.196
2.197 @code{bNode(e)} is the other end of the edge.
2.198
2.199 -???It is implemented in an other way now. (Member function <-> Graph global)???
2.200 +@deftypefun void Graph::setInvalid (EdgeIt &@var{e})
2.201 +@deftypefunx void Graph::setInvalid (EdgeIt &@var{e})
2.202 +These functions set the corresponding iterator to be invalid.
2.203 +@end deftypefun
2.204 +
2.205 +@c ???It is implemented in an other way now. (Member function <-> Graph global)???
2.206 @end deftypefun
2.207
2.208