Changeset 1631:e15162d8eca1 in lemon-0.x

Timestamp:

08/16/05 21:06:59 (19 years ago)

Author:

Alpar Juttner

Branch:

default

Phase:

public

Convert:

svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@2139

Message:

Fixed most (but not all) of Doxygen warnings

Files:

• doc/graph_io.dox (modified) (18 diffs)
• doc/graphs.dox (modified) (1 diff)
• doc/license.dox (modified) (1 diff)
• lemon/bfs.h (modified) (2 diffs)
• lemon/concept/graph.h (modified) (1 diff)
• lemon/concept/graph_component.h (modified) (1 diff)
• lemon/concept/undir_graph.h (modified) (4 diffs)
• lemon/dfs.h (modified) (2 diffs)
• lemon/dijkstra.h (modified) (2 diffs)
• lemon/graph_adaptor.h (modified) (2 diffs)
• lemon/kruskal.h (modified) (2 diffs)
• lemon/preflow.h (modified) (1 diff)
• lemon/smart_graph.h (modified) (3 diffs)

doc/graph_io.dox

@@ -123 +123 @@
 \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
@@ -132 +133 @@
 \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.
@@ -148 +151 @@
 \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.
 
@@ -161 +165 @@
 \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.
@@ -172 +178 @@
 \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
@@ -179 +186 @@
 \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.
 
@@ -190 +198 @@
 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.
 
@@ -202 +212 @@
 \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
@@ -219 +231 @@
 \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. 
 
@@ -227 +240 @@
 \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.
 
@@ -237 +252 @@
 \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
@@ -246 +262 @@
 \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.
 
@@ -258 +275 @@
 
 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.
@@ -338 +356 @@
 \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.
-
-The \c readUndirMap() function reads an undirected map and the
-\c readUndirEdge() reads an undirected edge from the file, 
+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 \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
@@ -365 +387 @@
 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
@@ -373 +398 @@
 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
@@ -415 +442 @@
 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
@@ -434 +461 @@
 \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.
 
 

doc/graphs.dox

@@ -35 +35 @@
 \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

doc/license.dox

@@ -3 +3 @@
 \page license License Terms
 
-\verbinclude ../LICENSE
+\verbinclude LICENSE
 
 */

lemon/bfs.h

@@ -699 +699 @@
     ///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.
@@ -714 +714 @@
     ///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.

lemon/concept/graph.h

@@ -405 +405 @@
         /// 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
 

lemon/concept/graph_component.h

@@ -764 +764 @@
 
     /// 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>

lemon/concept/undir_graph.h

@@ -233 +233 @@
     ///
     /// 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.
@@ -558 +558 @@
         /// 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
 
@@ -606 +606 @@
         ///@param n the node
         ///@param g the graph
-        OutEdgeIt(const UndirGraph&, const Node&) { }
+        OutEdgeIt(const UndirGraph& n, const Node& g) { }
         /// Edge -> OutEdgeIt conversion
 
@@ -655 +655 @@
         ///@param n the node
         ///@param g the graph
-        InEdgeIt(const UndirGraph&, const Node&) { }
+        InEdgeIt(const UndirGraph& g, const Node& n) { }
         /// Edge -> InEdgeIt conversion
 

lemon/dfs.h

@@ -709 +709 @@
     ///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.
@@ -724 +724 @@
     ///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.

lemon/dijkstra.h

@@ -703 +703 @@
     ///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.
@@ -714 +714 @@
     ///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:

lemon/graph_adaptor.h

@@ -1421 +1421 @@
   ///
   /// \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 :
@@ -1513 +1513 @@
   ///
   /// \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 :

lemon/kruskal.h

@@ -52 +52 @@
   /// \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.
@@ -89 +89 @@
   /// \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

lemon/preflow.h

@@ -284 +284 @@
 
     ///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

lemon/smart_graph.h

@@ -90 +90 @@
     /// 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; }
@@ -103 +103 @@
     
     /// 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.
@@ -112 +112 @@
     
     /// 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.