@deftp {Type} Graph::NodeType

 @c @deftp {Type} Graph::NodeType

 @deftpx {Type} Graph::EdgeType

 @c @deftpx {Type} Graph::EdgeType

 The type of the data stored statically for each node and edge.

 @c The type of the data stored statically for each node and edge.

 @end deftp

 @c @end deftp

 @deftpx {Type} Graph::NodeIterator

 @c @deftpx {Type} Graph::NodeIterator

 @deftpx {Type} Graph::BiEdgeIt

 @deftpx {Type} Graph::EachEdgeIt

 @deftpx {Type} Graph::SymEdgeIt

 @c @deftpx {Type} Graph::BiEdgeIt

 @c @deftpx {Type} Graph::SymEdgeIt

 @deftp {Type} Graph::EdgeIterator

 @c @deftp {Type} Graph::EdgeIterator

 @deftpx {Type} Graph::InEdgeIterator

 @c @deftpx {Type} Graph::InEdgeIterator

 @deftpx {Type} Graph::OutEdgeIterator

 @c @deftpx {Type} Graph::OutEdgeIterator

 @deftpx {Type} Graph::BiEdgeIterator

 @c @deftpx {Type} Graph::BiEdgeIterator

 @deftpx {Type} Graph::SymEdgeIterator

 @c @deftpx {Type} Graph::SymEdgeIterator

 @deftpx {Type} Graph::EachEdgeIterator

 @c @deftpx {Type} Graph::EachEdgeIterator

 Each of these types points an edge uniquely. The difference between the

 @c Each of these types points an edge uniquely. The difference between the

 @code{EdgeIt} and the @code{EdgeIterator} series is that

 @c @code{EdgeIt} and the @code{EdgeIterator} series is that

 @code{EdgeIt} requires the graph structure itself for most of the

 @c @code{EdgeIt} requires the graph structure itself for most of the

 operations. 

 @c operations. 

 For the @code{EdgeIterator} types you can use operator @code{++}

 @c For the @code{EdgeIterator} types you can use operator @code{++}

 (both the prefix and the posfix one) to obtain the next edge.

 @c (both the prefix and the posfix one) to obtain the next edge.

 @end deftp

 @c @end deftp

 @deftp {Type} Graph::NodeMap

 @deftp {Type} Graph::NodeMap<typename T>

 @deftpx {Type} Graph::EdgeMap

 @deftpx {Type} Graph::EdgeMap<typename T>

 The copy constructor. Not yet implemented.

 The copy constructor.

 @deftypefun NodeIterator Graph::addNode ()

 @deftypefun NodeIt Graph::addNode ()

 Adds a new node to the graph and returns a @code{NodeIterator} pointing to it.

 Adds a new node to the graph and returns a @code{NodeIt} pointing to it.

 @end deftypefun

 @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}})

 and returns an @code{EdgeIterator} pointing to it.

 and returns an @code{EdgeIt} pointing to it.

 @end deftypefun

 @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}})

 @deftypefun void Graph::delete (@w{const @mref{Graph-EdgeIterator,EdgeIterator} @var{e}})

 @deftypefun void Graph::delete (@w{const @mref{Graph-EdgeIterator,EdgeIt} @var{e}})

 @deftypefun void Graph::clean ()

 @deftypefun void Graph::clear ()

 @deftypefun NodeIt Graph::getFirst (NodeIt &@var{n})

 @deftypefun NodeIt Graph::getFirst (NodeIt &@var{n}) const

 @deftypefunx NodeIt Graph::next (const NodeIt @var{n})

 @deftypefunx NodeIt Graph::getNext (NodeIt @var{n}) const

 @deftypefunx {NodeIt &} Graph::goNext (NodeIt &@var{n})

 @deftypefunx {NodeIt &} Graph::next (NodeIt &@var{n})

 The nodes in the graph forms a list. @code{GetFirst(n)} sets @var{n} to

 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

 be the first node. @code{getNext(n)} gives back the subsequent

 node. @code{Next(n)} is equivalent to @code{n=Next(n)}, though it

 node. @code{next(n)} is equivalent to @code{n=getNext(n)}, though it

 @deftypefunx bool NodeIt::valid ()

 @c @deftypefunx bool NodeIt::valid ()

 ??? Which one should be implemented ???

 @c ??? Which one should be implemented ???

 @deftypefun EachEdgeIt Graph::getFirst (const EachEdgeIt & @var{e})

 @deftypefun EachEdgeIt Graph::getFirst (const EachEdgeIt & @var{e}) const

 @deftypefunx EachEdgeIt Graph::next (const EachEdgeIt @var{n})

 @deftypefunx EachEdgeIt Graph::getNext (EachEdgeIt @var{n}) const

 @deftypefunx {EachEdgeIt &} Graph::goNext (EachEdgeIt &@var{n})

 @deftypefunx {EachEdgeIt &} Graph::next (EachEdgeIt &@var{n})

 ??? What should be the return value ???

 @c ??? What should be the return value ???

 @end deftypefun

 @end deftypefun

 @deftypefun InEdgeIt Graph::getFirst (const InEdgeIt & @var{e}, const NodeIt @var{n})

 @deftypefun InEdgeIt &Graph::getFirst (InEdgeIt & @var{e}, const NodeIt @var{n})

 @deftypefunx OutEdgeIt Graph::getFirst (const OutEdgeIt & @var{e}, const NodeIt @var{n})

 @deftypefunx OutEdgeIt &Graph::getFirst (OutEdgeIt & @var{e}, const NodeIt @var{n})

 @deftypefunx SymEdgeIt Graph::getFirst (const SymEdgeIt & @var{e}, const NodeIt @var{n})

 @c @deftypefunx SymEdgeIt &Graph::getFirst (SymEdgeIt & @var{e}, const NodeIt @var{n})

 The edges leaving from, arriving at or adjacent with a node forms a

 The edges leaving from

 or

 arriving at

 @c or adjacent with

 a node forms a

 If @var{e} is a @code{SymEdgeIt} then

 @c If @var{e} is a @code{SymEdgeIt} then

 @code{getFirst} sets @var{e} to be the first incoming if there exists one

 @c @code{getFirst} sets @var{e} to be the first incoming if there exists one

 otherwise the first outgoing edge.

 @c otherwise the first outgoing 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)???