# HG changeset patch # User alpar # Date 1079682000 0 # Node ID fc4699a76a6f4e5e27c62a0d6faea4a3a07ca34f # Parent 0bd4fe53b1d0e141f26b6220663df5c239da449c . diff -r 0bd4fe53b1d0 -r fc4699a76a6f doc/Doxyfile --- a/doc/Doxyfile Fri Mar 19 07:39:09 2004 +0000 +++ b/doc/Doxyfile Fri Mar 19 07:40:00 2004 +0000 @@ -60,7 +60,8 @@ INPUT = ../src/demo/alpar/emptygraph.h \ ../src/doxy/invalid.h \ ../src/demo/alpar/smart_graph.h \ - ../src/demo/alpar/mapskeleton.h + ../src/demo/alpar/mapskeleton.h \ + maps.dox FILE_PATTERNS = RECURSIVE = NO EXCLUDE = diff -r 0bd4fe53b1d0 -r fc4699a76a6f doc/flf-graph.texi --- a/doc/flf-graph.texi Fri Mar 19 07:39:09 2004 +0000 +++ b/doc/flf-graph.texi Fri Mar 19 07:40:00 2004 +0000 @@ -21,14 +21,14 @@ @subsection Types -@deftp {Type} Graph::NodeType -@deftpx {Type} Graph::EdgeType -The type of the data stored statically for each node and edge. -@end deftp +@c @deftp {Type} Graph::NodeType +@c @deftpx {Type} Graph::EdgeType +@c The type of the data stored statically for each node and edge. +@c @end deftp @anchor{Graph-NodeIterator} @deftp {Type} Graph::NodeIt -@deftpx {Type} Graph::NodeIterator +@c @deftpx {Type} Graph::NodeIterator These types points a node uniquely. The difference between the @code{NodeIt} and the @code{NodeIterator} is that @code{NodeIt} requires the graph structure itself for most of the operations. @@ -58,8 +58,9 @@ @deftp {Type} Graph::EdgeIt @deftpx {Type} Graph::InEdgeIt @deftpx {Type} Graph::OutEdgeIt -@deftpx {Type} Graph::BiEdgeIt -@deftpx {Type} Graph::SymEdgeIt +@deftpx {Type} Graph::EachEdgeIt +@c @deftpx {Type} Graph::BiEdgeIt +@c @deftpx {Type} Graph::SymEdgeIt Each of these types points an edge uniquely. The difference between the @code{EdgeIt} and the @c @mref{Graph-NodeIterator,@code{EdgeIterator}} @@ -70,98 +71,106 @@ @end deftp @anchor{Graph-EdgeIterator} -@deftp {Type} Graph::EdgeIterator -@deftpx {Type} Graph::InEdgeIterator -@deftpx {Type} Graph::OutEdgeIterator -@deftpx {Type} Graph::BiEdgeIterator -@deftpx {Type} Graph::SymEdgeIterator -@deftpx {Type} Graph::EachEdgeIterator -Each of these types points an edge uniquely. The difference between the -@code{EdgeIt} and the @code{EdgeIterator} series is that -@code{EdgeIt} requires the graph structure itself for most of the -operations. +@c @deftp {Type} Graph::EdgeIterator +@c @deftpx {Type} Graph::InEdgeIterator +@c @deftpx {Type} Graph::OutEdgeIterator +@c @deftpx {Type} Graph::BiEdgeIterator +@c @deftpx {Type} Graph::SymEdgeIterator +@c @deftpx {Type} Graph::EachEdgeIterator +@c Each of these types points an edge uniquely. The difference between the +@c @code{EdgeIt} and the @code{EdgeIterator} series is that +@c @code{EdgeIt} requires the graph structure itself for most of the +@c operations. -For the @code{EdgeIterator} types you can use operator @code{++} -(both the prefix and the posfix one) to obtain the next edge. -@end deftp +@c For the @code{EdgeIterator} types you can use operator @code{++} +@c (both the prefix and the posfix one) to obtain the next edge. +@c @end deftp -@deftp {Type} Graph::NodeMap -@deftpx {Type} Graph::EdgeMap +@deftp {Type} Graph::NodeMap +@deftpx {Type} Graph::EdgeMap There are the default property maps for the edges and the nodes. @end deftp +@deftp {Type} Graph::DynNodeMap +@deftpx {Type} Graph::DynEdgeMap +There are the default @emph{dynamic} property maps for the edges and the nodes. +@end deftp @subsection Member Functions @subsubsection Constructors - @deftypefun { } Graph::Graph () The default constructor. @end deftypefun @c @deftypefun { } Graph::Graph (Graph@tie{}&) @deftypefun { } Graph::Graph (Graph &) -The copy constructor. Not yet implemented. +The copy constructor. @end deftypefun @subsubsection Graph Maintenence Operations -@deftypefun NodeIterator Graph::addNode () -Adds a new node to the graph and returns a @code{NodeIterator} pointing to it. +@deftypefun NodeIt Graph::addNode () +Adds a new node to the graph and returns a @code{NodeIt} pointing to it. @end deftypefun -@deftypefun EdgeIterator Graph::addEdge (@w{const @mref{Graph-NodeIterator,NodeIterator} @var{from}}, @w{const @mref{Graph-NodeIterator,NodeIterator} @var{to}}) +@deftypefun EdgeIt Graph::addEdge (@w{const @mref{Graph-NodeIterator,NodeIt} @var{from}}, @w{const @mref{Graph-NodeIterator,NodeIt} @var{to}}) Adds a new edge with tail @var{from} and head @var{to} to the graph -and returns an @code{EdgeIterator} pointing to it. +and returns an @code{EdgeIt} pointing to it. @end deftypefun -@deftypefun void Graph::delete (@w{const @mref{Graph-NodeIterator,NodeIterator} @var{n}}) +@deftypefun void Graph::delete (@w{const @mref{Graph-NodeIterator,NodeIt} @var{n}}) Deletes the node @var{n}. It also deletes the adjacent edges. @end deftypefun -@deftypefun void Graph::delete (@w{const @mref{Graph-EdgeIterator,EdgeIterator} @var{e}}) +@deftypefun void Graph::delete (@w{const @mref{Graph-EdgeIterator,EdgeIt} @var{e}}) Deletes the edge @var{n}. @end deftypefun -@deftypefun void Graph::clean () +@deftypefun void Graph::clear () Deletes all edges and nodes from the graph. @end deftypefun @deftypefun int Graph::nodeNum () Returns the number of the nodes in the graph. +??? Is it necessary??? @end deftypefun @subsubsection NodeIt Operations -@deftypefun NodeIt Graph::getFirst (NodeIt &@var{n}) -@deftypefunx NodeIt Graph::next (const NodeIt @var{n}) -@deftypefunx {NodeIt &} Graph::goNext (NodeIt &@var{n}) -The nodes in the graph forms a list. @code{GetFirst(n)} sets @var{n} to -be the first node. @code{next(n)} gives back the subsequent -node. @code{Next(n)} is equivalent to @code{n=Next(n)}, though it +@deftypefun NodeIt Graph::getFirst (NodeIt &@var{n}) const +@deftypefunx NodeIt Graph::getNext (NodeIt @var{n}) const +@deftypefunx {NodeIt &} Graph::next (NodeIt &@var{n}) +The nodes in the graph forms a list. @code{getFirst(n)} sets @var{n} to +be the first node. @code{getNext(n)} gives back the subsequent +node. @code{next(n)} is equivalent to @code{n=getNext(n)}, though it might be faster. ??? What should be the return value ??? @end deftypefun @deftypefun bool Graph::valid (NodeIt &@var{e}) -@deftypefunx bool NodeIt::valid () +@c @deftypefunx bool NodeIt::valid () These functions check if and NodeIt is valid or not. -??? Which one should be implemented ??? +@c ??? Which one should be implemented ??? @end deftypefun @subsubsection EdgeIt Operations -@deftypefun EachEdgeIt Graph::getFirst (const EachEdgeIt & @var{e}) -@deftypefunx EachEdgeIt Graph::next (const EachEdgeIt @var{n}) -@deftypefunx {EachEdgeIt &} Graph::goNext (EachEdgeIt &@var{n}) +@deftypefun EachEdgeIt Graph::getFirst (const EachEdgeIt & @var{e}) const +@deftypefunx EachEdgeIt Graph::getNext (EachEdgeIt @var{n}) const +@deftypefunx {EachEdgeIt &} Graph::next (EachEdgeIt &@var{n}) With these functions you can go though all the edges of the graph. -??? What should be the return value ??? +@c ??? What should be the return value ??? @end deftypefun -@deftypefun InEdgeIt Graph::getFirst (const InEdgeIt & @var{e}, const NodeIt @var{n}) -@deftypefunx OutEdgeIt Graph::getFirst (const OutEdgeIt & @var{e}, const NodeIt @var{n}) -@deftypefunx SymEdgeIt Graph::getFirst (const SymEdgeIt & @var{e}, const NodeIt @var{n}) -The edges leaving from, arriving at or adjacent with a node forms a +@deftypefun InEdgeIt &Graph::getFirst (InEdgeIt & @var{e}, const NodeIt @var{n}) +@deftypefunx OutEdgeIt &Graph::getFirst (OutEdgeIt & @var{e}, const NodeIt @var{n}) +@c @deftypefunx SymEdgeIt &Graph::getFirst (SymEdgeIt & @var{e}, const NodeIt @var{n}) +The edges leaving from +or +arriving at +@c or adjacent with +a node forms a list. These functions give back the first elements of these lists. The exact behavior depends on the type of @var{e}. @@ -169,9 +178,9 @@ @code{getFirst} sets @var{e} to be the first incoming or outgoing edge of the node @var{n}, respectively. -If @var{e} is a @code{SymEdgeIt} then -@code{getFirst} sets @var{e} to be the first incoming if there exists one -otherwise the first outgoing edge. +@c If @var{e} is a @code{SymEdgeIt} then +@c @code{getFirst} sets @var{e} to be the first incoming if there exists one +@c otherwise the first outgoing edge. If there are no such edges, @var{e} will be invalid. @@ -218,7 +227,12 @@ @code{bNode(e)} is the other end of the edge. -???It is implemented in an other way now. (Member function <-> Graph global)??? +@deftypefun void Graph::setInvalid (EdgeIt &@var{e}) +@deftypefunx void Graph::setInvalid (EdgeIt &@var{e}) +These functions set the corresponding iterator to be invalid. +@end deftypefun + +@c ???It is implemented in an other way now. (Member function <-> Graph global)??? @end deftypefun