Index: doc/Doxyfile
===================================================================
--- doc/Doxyfile	(revision 186)
+++ doc/Doxyfile	(revision 203)
@@ -61,5 +61,6 @@
                          ../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
Index: doc/flf-graph.texi
===================================================================
--- doc/flf-graph.texi	(revision 70)
+++ doc/flf-graph.texi	(revision 203)
@@ -22,12 +22,12 @@
 @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}
@@ -59,6 +59,7 @@
 @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
@@ -71,29 +72,32 @@
 
 @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. 
-
-For the @code{EdgeIterator} types you can use operator @code{++}
-(both the prefix and the posfix one) to obtain the next edge.
-@end deftp
-
-@deftp {Type} Graph::NodeMap
-@deftpx {Type} Graph::EdgeMap
+@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. 
+
+@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<typename T>
+@deftpx {Type} Graph::EdgeMap<typename T>
 There are the default property maps for the edges and the nodes.
 @end deftp
 
+@deftp {Type} Graph::DynNodeMap<typename T>
+@deftpx {Type} Graph::DynEdgeMap<typename T>
+There are the default @emph{dynamic} property maps for the edges and the nodes.
+@end deftp
 
 @subsection Member Functions
 
 @subsubsection Constructors
-
 
 @deftypefun { } Graph::Graph ()
@@ -103,27 +107,27 @@
 @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.
-@end deftypefun
-
-@deftypefun EdgeIterator Graph::addEdge (@w{const @mref{Graph-NodeIterator,NodeIterator} @var{from}}, @w{const @mref{Graph-NodeIterator,NodeIterator} @var{to}})
+@deftypefun NodeIt Graph::addNode ()
+Adds a new node to the graph and returns a @code{NodeIt} pointing to it.
+@end deftypefun
+
+@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.
-@end deftypefun
-
-@deftypefun void Graph::delete (@w{const @mref{Graph-NodeIterator,NodeIterator} @var{n}})
+and returns an @code{EdgeIt} pointing to it.
+@end deftypefun
+
+@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
@@ -131,36 +135,41 @@
 @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 ???
-@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
+@c ??? What should be the return value ???
+@end deftypefun
+
+@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}.
@@ -170,7 +179,7 @@
 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.
@@ -219,5 +228,10 @@
 @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
 
