# HG changeset patch
# User alpar
# Date 1124219219 0
# Node ID e15162d8eca11733bb05d8fcab1a781727a06dc9
# Parent  f67737f5727adf7e8209c9fdc1b6a8e348474e80
Fixed most (but not all) of Doxygen warnings

diff -r f67737f5727a -r e15162d8eca1 doc/graph_io.dox
--- a/doc/graph_io.dox	Tue Aug 16 16:44:57 2005 +0000
+++ b/doc/graph_io.dox	Tue Aug 16 19:06:59 2005 +0000
@@ -122,7 +122,8 @@
 
 \subsection write Writing a graph
 
-The \c GraphWriter class provides the graph output. To write a graph
+The \ref lemon::GraphWriter "GraphWriter" template class
+provides the graph output. To write a graph
 you should first give writing commands to the writer. You can declare
 writing command as \c NodeMap or \c EdgeMap writing and labeled Node and
 Edge writing.
@@ -131,8 +132,10 @@
 GraphWriter<ListGraph> writer(std::cout, graph);
 \endcode
 
-The \c writeNodeMap() function declares a \c NodeMap writing command in the
-\c GraphWriter. You should give a name to the map and the map
+The \ref lemon::GraphWriter::writeNodeMap() "writeNodeMap()"
+function declares a \c NodeMap writing command in the
+\ref lemon::GraphWriter "GraphWriter".
+You should give a name to the map and the map
 object as parameters. The NodeMap writing command with name "id" should write a 
 unique map because it will be regarded as an ID map.
 
@@ -147,7 +150,8 @@
 writer.writeNodeMap("color", colorMap);
 \endcode
 
-With the \c writeEdgeMap() member function you can give an edge map
+With the \ref lemon::GraphWriter::writeEdgeMap() "writeEdgeMap()"
+member function you can give an edge map
 writing command similar to the NodeMaps.
 
 \see IdMap, DescriptorMap  
@@ -160,7 +164,9 @@
 writer.writeEdgeMap("label", labelMap);
 \endcode
 
-With \c writeNode() and \c writeEdge() functions you can designate Nodes and
+With \ref lemon::GraphWriter::writeNode() "writeNode()"
+and \ref lemon::GraphWriter::writeEdge() "writeEdge()"
+functions you can designate Nodes and
 Edges in the graph. For example, you can write out the source and target node
 of a maximum flow instance.
 
@@ -171,14 +177,16 @@
 writer.writeEdge("observed", edge);
 \endcode
 
-With \c writeAttribute() function you can write an attribute to the file.
+With \ref lemon::GraphWriter::writeAttribute() "writeAttribute()"
+function you can write an attribute to the file.
 
 \code
 writer.writeAttribute("author", "Balazs DEZSO");
 writer.writeAttribute("version", 12);
 \endcode
 
-After you give all write commands you must call the \c run() member
+After you give all write commands you must call the
+\ref lemon::GraphWriter::run() "run()" member
 function, which executes all the writing commands.
 
 \code
@@ -189,8 +197,10 @@
 
 The file to be read may contain several maps and labeled nodes or edges.
 If you read a graph you need not read all the maps and items just those
-that you need. The interface of the \c GraphReader is very similar to
-the GraphWriter but the reading method does not depend on the order of the
+that you need. The interface of the \ref lemon::GraphReader "GraphReader"
+is very similar to
+the \ref lemon::GraphWriter "GraphWriter"
+but the reading method does not depend on the order of the
 given commands.
 
 The reader object assumes that each not readed value does not contain 
@@ -201,10 +211,12 @@
 GraphReader<ListGraph> reader(std::cin, graph);
 \endcode
 
-The \c readNodeMap() function reads a map from the \c nodeset section.
+The \ref lemon::GraphReader::readNodeMap() "readNodeMap()"
+function reads a map from the \c nodeset section.
 If there is a map that you do not want to read from the file and there are
 whitespaces in the string represenation of the values then you should
-call the \c skipNodeMap() template member function with proper parameters.
+call the \ref lemon::GraphReader::skipNodeMap() "skipNodeMap()"
+template member function with proper parameters.
 
 \see QuotedStringReader
 
@@ -218,7 +230,8 @@
 reader.readNodeMap("color", colorMap);
 \endcode
 
-With the \c readEdgeMap() member function you can give an edge map
+With the \ref lemon::GraphReader::readEdgeMap() "readEdgeMap()"
+member function you can give an edge map
 reading command similar to the NodeMaps. 
 
 \code
@@ -226,7 +239,9 @@
 reader.readEdgeMap("label", labelMap);
 \endcode
 
-With \c readNode() and \c readEdge() functions you can read labeled Nodes and
+With \ref lemon::GraphReader::readNode() "readNode()"
+and \ref lemon::GraphReader::readEdge() "readEdge()"
+functions you can read labeled Nodes and
 Edges.
 
 \code
@@ -236,7 +251,8 @@
 reader.readEdge("observed", edge);
 \endcode
 
-With \c readAttribute() function you can read an attribute from the file.
+With \ref lemon::GraphReader::readAttribute() "readAttribute()"
+function you can read an attribute from the file.
 
 \code
 std::string author;
@@ -245,7 +261,8 @@
 writer.writeAttribute("version", version);
 \endcode
 
-After you give all read commands you must call the \c run() member
+After you give all read commands you must call the
+\ref lemon::GraphReader::run() "run()" member
 function, which executes all the commands.
 
 \code
@@ -257,7 +274,8 @@
 
 
 To read a map (on the nodes or edges)
-the \c GraphReader should know how to read a Value from the given map.
+the \ref lemon::GraphReader "GraphReader"
+should know how to read a Value from the given map.
 By the default implementation the input operator reads a value from
 the stream and the type of the readed value is the value type of the given map.
 When the reader should skip a value in the stream, because you do not
@@ -337,12 +355,16 @@
 -back 5
 \endcode
 
-There are similar classes to the \c GraphReader ans \c GraphWriter
-which handle the undirected graphs. These classes are the 
-\c UndirGraphReader and \UndirGraphWriter.
+There are similar classes to the \ref lemon::GraphReader "GraphReader" and
+\ref lemon::GraphWriter "GraphWriter" which
+handle the undirected graphs. These classes are
+the \ref lemon::UndirGraphReader "UndirGraphReader"
+and \ref lemon::UndirGraphWriter "UndirGraphWriter".
 
-The \c readUndirMap() function reads an undirected map and the
-\c readUndirEdge() reads an undirected edge from the file, 
+The \ref lemon::UndirGraphReader::readUndirMap() "readUndirMap()"
+function reads an undirected map and the
+\ref lemon::UndirGraphReader::readUndirEdge() "readUndirEdge()"
+reads an undirected edge from the file, 
 
 \code
 reader.readUndirEdgeMap("capacity", capacityMap);
@@ -364,15 +386,20 @@
 The content of the section this way cannot contain line with \c \@ first
 character. The file may contains comment lines with \c # first character.
 
-The \c LemonReader and \c LemonWriter gives a framework to read and
+The \ref lemon::LemonReader "LemonReader"
+and \ref lemon::LemonWriter "LemonWriter"
+gives a framework to read and
 write sections. There are various section reader and section writer
-classes which can be attached to a \c LemonReader or a \c LemonWriter.
+classes which can be attached to a \ref lemon::LemonReader "LemonReader"
+or a \ref lemon::LemonWriter "LemonWriter".
 
 There are default section readers and writers for reading and writing
 item sets, and labeled items in the graph. These read and write
 the format described above. Other type of data can be handled with own
 section reader and writer classes which are inherited from the
-\c LemonReader::SectionReader or the \c LemonWriter::SectionWriter classes.
+\c LemonReader::SectionReader or the
+\ref lemon::LemonWriter::SectionWriter "LemonWriter::SectionWriter"
+classes.
 
 The next example defines a special section reader which reads the
 \c \@description sections into a string:
@@ -414,8 +441,8 @@
 
 In our example there is a network with symmetric links and there are assymetric
 traffic request on the network. This construction can be stored in an
-undirected graph and in a directed NewEdgeSetAdaptor class. The example
-shows the input with the LemonReader class:
+undirected graph and in a directed \c NewEdgeSetAdaptor class. The example
+shows the input with the \ref lemon::LemonReader "LemonReader" class:
 
 \code
 UndirListGraph network;
@@ -433,9 +460,12 @@
 reader.run();
 \endcode
 
-Because the GraphReader and the UndirGraphReader can be converted
-to LemonReader and it can resolve the ID's of the items, the previous
-result can be achived with the UndirGraphReader class, too.
+Because both the \ref lemon::GraphReader "GraphReader"
+and the \ref lemon::UndirGraphReader "UndirGraphReader" can be converted
+to \ref lemon::LemonReader "LemonReader"
+and it can resolve the ID's of the items, the previous
+result can be achived with the \ref lemon::UndirGraphReader "UndirGraphReader"
+class, too.
 
 
 \code
@@ -454,4 +484,4 @@
 
 \author Balazs Dezso
 */
-}
+}
\ No newline at end of file
diff -r f67737f5727a -r e15162d8eca1 doc/graphs.dox
--- a/doc/graphs.dox	Tue Aug 16 16:44:57 2005 +0000
+++ b/doc/graphs.dox	Tue Aug 16 19:06:59 2005 +0000
@@ -34,15 +34,6 @@
 price of this is that it only meets the
 \ref lemon::concept::ExtendableGraph "ExtendableGraph" concept,
 so you cannot delete individual edges or nodes.
-\li \ref lemon::SymListGraph "SymListGraph" and
-\ref lemon::SymSmartGraph "SymSmartGraph" classes are very similar to
-\ref lemon::ListGraph "ListGraph" and \ref lemon::SmartGraph "SmartGraph".
-The difference is that whenever you add a
-new edge to the graph, it actually adds a pair of oppositely directed edges.
-They are linked together so it is possible to access the counterpart of an
-edge. An even more important feature is that using these classes you can also
-attach data to the edges in such a way that the stored data
-are shared by the edge pairs. 
 \li \ref lemon::FullGraph "FullGraph"
 implements a complete graph. It is a
 \ref lemon::concept::StaticGraph "StaticGraph", so you cannot
diff -r f67737f5727a -r e15162d8eca1 doc/license.dox
--- a/doc/license.dox	Tue Aug 16 16:44:57 2005 +0000
+++ b/doc/license.dox	Tue Aug 16 19:06:59 2005 +0000
@@ -2,6 +2,6 @@
 
 \page license License Terms
 
-\verbinclude ../LICENSE
+\verbinclude LICENSE
 
 */
\ No newline at end of file
diff -r f67737f5727a -r e15162d8eca1 lemon/bfs.h
--- a/lemon/bfs.h	Tue Aug 16 16:44:57 2005 +0000
+++ b/lemon/bfs.h	Tue Aug 16 19:06:59 2005 +0000
@@ -698,7 +698,7 @@
     ///v. It is \ref INVALID
     ///if \c v is unreachable from the root(s) or \c v is a root. The
     ///shortest path tree used here is equal to the shortest path tree used in
-    ///\ref predNode(Node v).
+    ///\ref predNode().
     ///\pre Either \ref run() or \ref start() must be called before using
     ///this function.
     ///\todo predEdge could be a better name.
@@ -713,7 +713,7 @@
     ///It is INVALID if \c v is unreachable from the root(s) or
     ///if \c v itself a root.
     ///The shortest path tree used here is equal to the shortest path
-    ///tree used in \ref pred(Node v).
+    ///tree used in \ref pred().
     ///\pre Either \ref run() or \ref start() must be called before
     ///using this function.
     Node predNode(Node v) const { return (*_pred)[v]==INVALID ? INVALID:
diff -r f67737f5727a -r e15162d8eca1 lemon/concept/graph.h
--- a/lemon/concept/graph.h	Tue Aug 16 16:44:57 2005 +0000
+++ b/lemon/concept/graph.h	Tue Aug 16 19:06:59 2005 +0000
@@ -404,7 +404,7 @@
     
         /// This constructor sets the iterator to the first edge of \c g.
         ///@param g the graph
-        EdgeIt(const StaticGraph&) { }
+        EdgeIt(const StaticGraph& g) { }
         /// Edge -> EdgeIt conversion
 
         /// Sets the iterator to the value of the trivial iterator \c e.
diff -r f67737f5727a -r e15162d8eca1 lemon/concept/graph_component.h
--- a/lemon/concept/graph_component.h	Tue Aug 16 16:44:57 2005 +0000
+++ b/lemon/concept/graph_component.h	Tue Aug 16 19:06:59 2005 +0000
@@ -763,7 +763,7 @@
     /// Class describing the concept of graph maps
 
     /// This class describes the common interface of the graph maps
-    /// (NodeMap, EdgeMap), that is \ref maps-pages "maps" which can be used to
+    /// (NodeMap, EdgeMap), that is \ref maps-page "maps" which can be used to
     /// associate data to graph descriptors (nodes or edges).
     template <typename Graph, typename Item, typename _Value>
     class GraphMap : public ReadWriteMap<Item, _Value> {
diff -r f67737f5727a -r e15162d8eca1 lemon/concept/undir_graph.h
--- a/lemon/concept/undir_graph.h	Tue Aug 16 16:44:57 2005 +0000
+++ b/lemon/concept/undir_graph.h	Tue Aug 16 19:06:59 2005 +0000
@@ -232,7 +232,7 @@
     /// run properly, of couse.
     ///
     /// In LEMON undirected graphs also fulfill the concept of directed
-    /// graphs (\ref lemon::concept::Graph "Graph Concept"). For
+    /// graphs (\ref lemon::concept::StaticGraph "Graph Concept"). For
     /// explanation of this and more see also the page \ref undir_graphs,
     /// a tutorial about undirected graphs.
     ///
@@ -557,7 +557,7 @@
     
         /// This constructor sets the iterator to the first edge of \c g.
         ///@param g the graph
-        EdgeIt(const UndirGraph&) { }
+        EdgeIt(const UndirGraph &g) { }
         /// Edge -> EdgeIt conversion
 
         /// Sets the iterator to the value of the trivial iterator \c e.
@@ -605,7 +605,7 @@
         /// the node.
         ///@param n the node
         ///@param g the graph
-        OutEdgeIt(const UndirGraph&, const Node&) { }
+        OutEdgeIt(const UndirGraph& n, const Node& g) { }
         /// Edge -> OutEdgeIt conversion
 
         /// Sets the iterator to the value of the trivial iterator.
@@ -654,7 +654,7 @@
         /// the node.
         ///@param n the node
         ///@param g the graph
-        InEdgeIt(const UndirGraph&, const Node&) { }
+        InEdgeIt(const UndirGraph& g, const Node& n) { }
         /// Edge -> InEdgeIt conversion
 
         /// Sets the iterator to the value of the trivial iterator \c e.
diff -r f67737f5727a -r e15162d8eca1 lemon/dfs.h
--- a/lemon/dfs.h	Tue Aug 16 16:44:57 2005 +0000
+++ b/lemon/dfs.h	Tue Aug 16 19:06:59 2005 +0000
@@ -708,7 +708,7 @@
     ///v. It is \ref INVALID
     ///if \c v is unreachable from the root(s) or \c v is a root. The
     ///%DFS tree used here is equal to the %DFS tree used in
-    ///\ref predNode(Node v).
+    ///\ref predNode().
     ///\pre Either \ref run() or \ref start() must be called before using
     ///this function.
     ///\todo predEdge could be a better name.
@@ -723,7 +723,7 @@
     ///It is INVALID if \c v is unreachable from the root(s) or
     ///if \c v itself a root.
     ///The %DFS tree used here is equal to the %DFS
-    ///tree used in \ref pred(Node v).
+    ///tree used in \ref pred().
     ///\pre Either \ref run() or \ref start() must be called before
     ///using this function.
     Node predNode(Node v) const { return (*_pred)[v]==INVALID ? INVALID:
diff -r f67737f5727a -r e15162d8eca1 lemon/dijkstra.h
--- a/lemon/dijkstra.h	Tue Aug 16 16:44:57 2005 +0000
+++ b/lemon/dijkstra.h	Tue Aug 16 19:06:59 2005 +0000
@@ -702,7 +702,7 @@
     ///v. It is \ref INVALID
     ///if \c v is unreachable from the root or if \c v=s. The
     ///shortest path tree used here is equal to the shortest path tree used in
-    ///\ref predNode(Node v).  \pre \ref run() must be called before using
+    ///\ref predNode().  \pre \ref run() must be called before using
     ///this function.
     ///\todo predEdge could be a better name.
     Edge pred(Node v) const { return (*_pred)[v]; }
@@ -713,7 +713,7 @@
     ///i.e. it returns the last but one node from a shortest path from the
     ///root to \c /v. It is INVALID if \c v is unreachable from the root or if
     ///\c v=s. The shortest path tree used here is equal to the shortest path
-    ///tree used in \ref pred(Node v).  \pre \ref run() must be called before
+    ///tree used in \ref pred().  \pre \ref run() must be called before
     ///using this function.
     Node predNode(Node v) const { return (*_pred)[v]==INVALID ? INVALID:
 				  G->source((*_pred)[v]); }
diff -r f67737f5727a -r e15162d8eca1 lemon/graph_adaptor.h
--- a/lemon/graph_adaptor.h	Tue Aug 16 16:44:57 2005 +0000
+++ b/lemon/graph_adaptor.h	Tue Aug 16 19:06:59 2005 +0000
@@ -1420,11 +1420,11 @@
   /// original graph.
   ///
   /// \param _Graph The type of the graph which shares its node set with 
-  /// this class. Its interface must conform to the \ref skeleton::StaticGraph
+  /// this class. Its interface must conform to the \ref concept::StaticGraph
   /// "StaticGraph" concept.
   ///
   /// In the edge extension and removing it conforms to the 
-  /// \ref skeleton::ExtendableGraph "ExtendableGraph" concept.
+  /// \ref concept::ExtendableGraph "ExtendableGraph" concept.
   template <typename _Graph>
   class NewEdgeSetAdaptor :
     public ErasableGraphExtender<
@@ -1512,11 +1512,11 @@
   /// nodes of the original graph.
   ///
   /// \param _Graph The type of the graph which shares its node set with 
-  /// this class. Its interface must conform to the \ref skeleton::StaticGraph
+  /// this class. Its interface must conform to the \ref concept::StaticGraph
   /// "StaticGraph" concept.
   ///
   /// In the edge extension and removing it conforms to the 
-  /// \ref skeleton::ExtendableGraph "ExtendableGraph" concept.
+  /// \ref concept::ExtendableGraph "ExtendableGraph" concept.
   template <typename _Graph>
   class NewUndirEdgeSetAdaptor :
     public ErasableUndirGraphExtender<
diff -r f67737f5727a -r e15162d8eca1 lemon/kruskal.h
--- a/lemon/kruskal.h	Tue Aug 16 16:44:57 2005 +0000
+++ b/lemon/kruskal.h	Tue Aug 16 19:06:59 2005 +0000
@@ -51,7 +51,7 @@
   ///
   /// \param g The graph the algorithm runs on.
   /// It can be either \ref concept::StaticGraph "directed" or 
-  /// \ref concept::UndirStaticGraph "undirected".
+  /// \ref concept::UndirGraph "undirected".
   /// If the graph is directed, the algorithm consider it to be 
   /// undirected by disregarding the direction of the edges.
   ///
@@ -88,7 +88,8 @@
   ///
   /// \return The cost of the found tree.
   ///
-  /// \warning If kruskal is run on an \ref undirected graph, be sure that the
+  /// \warning If kruskal is run on an
+  /// \ref lemon::concept::UndirGraph "undirected graph", be sure that the
   /// map storing the tree is also undirected
   /// (e.g. UndirListGraph::UndirEdgeMap<bool>, otherwise the values of the
   /// half of the edges will not be set.
diff -r f67737f5727a -r e15162d8eca1 lemon/preflow.h
--- a/lemon/preflow.h	Tue Aug 16 16:44:57 2005 +0000
+++ b/lemon/preflow.h	Tue Aug 16 19:06:59 2005 +0000
@@ -283,8 +283,9 @@
     ///Runs the second phase of the preflow algorithm.
 
     ///The preflow algorithm consists of two phases, this method runs
-    ///the second phase. After calling \ref phase1 and then \ref
-    ///phase2, \ref flow contains a maximum flow, \ref flowValue
+    ///the second phase. After calling \ref phase1() and then
+    ///\ref phase2(),
+    /// \ref flowMap() return a maximum flow, \ref flowValue
     ///returns the value of a maximum flow, \ref minCut returns a
     ///minimum cut, while the methods \ref minMinCut and \ref
     ///maxMinCut return the inclusionwise minimum and maximum cuts of
diff -r f67737f5727a -r e15162d8eca1 lemon/smart_graph.h
--- a/lemon/smart_graph.h	Tue Aug 16 16:44:57 2005 +0000
+++ b/lemon/smart_graph.h	Tue Aug 16 19:06:59 2005 +0000
@@ -89,12 +89,12 @@
     
     /// Maximum node ID.
     ///\sa id(Node)
-    int maxId(Node = INVALID) const { return nodes.size()-1; }
+    int maxId(Node) const { return nodes.size()-1; }
     /// Maximum edge ID.
     
     /// Maximum edge ID.
     ///\sa id(Edge)
-    int maxId(Edge = INVALID) const { return edges.size()-1; }
+    int maxId(Edge) const { return edges.size()-1; }
 
     Node source(Edge e) const { return edges[e.n].source; }
     Node target(Edge e) const { return edges[e.n].target; }
@@ -102,8 +102,8 @@
     /// Node ID.
     
     /// The ID of a valid Node is a nonnegative integer not greater than
-    /// \ref maxNodeId(). The range of the ID's is not surely continuous
-    /// and the greatest node ID can be actually less then \ref maxNodeId().
+    /// \ref maxId(Node). The range of the ID's is not surely continuous
+    /// and the greatest node ID can be actually less then \ref maxId(Node).
     ///
     /// The ID of the \ref INVALID node is -1.
     ///\return The ID of the node \c v. 
@@ -111,8 +111,8 @@
     /// Edge ID.
     
     /// The ID of a valid Edge is a nonnegative integer not greater than
-    /// \ref maxEdgeId(). The range of the ID's is not surely continuous
-    /// and the greatest edge ID can be actually less then \ref maxEdgeId().
+    /// \ref maxId(Edge). The range of the ID's is not surely continuous
+    /// and the greatest edge ID can be actually less then \ref maxId(Edge).
     ///
     /// The ID of the \ref INVALID edge is -1.
     ///\return The ID of the edge \c e.