Changeset 2476:059dcdda37c5 in lemon-0.x

Timestamp:

09/27/07 15:04:06 (17 years ago)

Author:

Peter Kovacs

Branch:

default

Phase:

public

Convert:

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

Message:

Bug fixes in the documentation (mainly bad references).

Files:

• demo/eps_demo.cc (modified) (1 diff)
• doc/algorithms.dox (modified) (1 diff)
• doc/basic_concepts.dox (modified) (3 diffs)
• doc/graphs.dox (modified) (6 diffs)
• doc/maps1.dox (modified) (4 diffs)
• lemon/bellman_ford.h (modified) (4 diffs)
• lemon/bfs.h (modified) (3 diffs)
• lemon/dfs.h (modified) (2 diffs)
• lemon/dijkstra.h (modified) (1 diff)
• lemon/error.h (modified) (1 diff)
• lemon/graph_utils.h (modified) (1 diff)
• lemon/lemon_reader.h (modified) (2 diffs)

demo/eps_demo.cc

@@ -19 +19 @@
 /// \ingroup demos
 /// \file
-/// \brief Demo of the EPS grawing class \ref EpsDrawer()
+/// \brief Demo of the EPS grawing class \ref lemon::EpsDrawer "EpsDrawer".
 ///
 /// This demo program shows examples how to use the class \ref
-/// EpsDrawer(). It takes no input but simply creates a file
-/// <tt>eps_demo.eps</tt> demonstrating the capability of \ref
-/// EpsDrawer().
+/// lemon::EpsDrawer "EpsDrawer". It takes no input but simply creates
+/// a file <tt>eps_demo.eps</tt> demonstrating the capability of \ref
+/// lemon::EpsDrawer "EpsDrawer".
 ///
 /// \include eps_demo.cc

doc/algorithms.dox

@@ -115 +115 @@
 \skip MyOrdererMap
 \until };
-The class meets the \ref lemon::WriteMap "WriteMap" concept. In it's \c set() method the only thing
+The class meets the \ref concepts::WriteMap "WriteMap" concept. In it's \c set() method the only thing
 we need to do is insert the key - that is the node whose processing just finished - into the beginning
 of the list.<br>

doc/basic_concepts.dox

@@ -30 +30 @@
 have to satisfy one or more \ref concept "graph concepts" which are standardized
 interfaces to work with the rest of the library. The most basic concept is the
-\ref Graph.<br>
+\ref concepts::Graph "Graph".<br>
 A good example is the \ref ListGraph which we already know from Hello World and
 will be used in our examples as well.
@@ -48 +48 @@
 to the graph with the addNode() member function. It returns the newly added node
 (as value). So if you need the new node to do something useful with, for example
-create an edge, assign a value to it through \ref map1 maps.
+create an edge, assign a value to it through \ref maps1 maps.
 \code lemon::ListGraph::Node  new_node = graph.addNode(); \endcode
 
@@ -115 +115 @@
 the next page.)
 
-The \ref EdgeIt works exactly the same - nothing more to say. But there are \ref InEdgeIt
-and \ref OutEdgeIt by directed graphs and \ref IncEdgeIt by undirected graphs.
+The \ref concepts::Graph::EdgeIt "EdgeIt" works exactly the same - nothing more to say.
+But there are \ref concepts::Graph::InEdgeIt "InEdgeIt" and
+\ref concepts::Graph::OutEdgeIt "OutEdgeIt" by directed graphs and
+\ref concepts::UGraph::IncEdgeIt "IncEdgeIt" by undirected graphs.
 They take two arguments. The first is a graph, the second is certain node of the
 graph. InEdgeIt iterates on the incoming edges of that node and OutEdgeIt does it

doc/graphs.dox

@@ -17 +17 @@
  */
 
+namespace lemon {
+
 /*!
-
 \page graphs Graphs
 
@@ -30 +31 @@
 as  incoming and outgoing edges of a given node. 
 
-Each graph should meet the \ref lemon::concepts::Graph "Graph" concept.
+Each graph should meet the \ref concepts::Graph "Graph" concept.
 This concept does not make it possible to change the graph (i.e. it is
 not possible to add or delete edges or nodes). Most of the graph
@@ -37 +38 @@
 
 In case of graphs meeting the full feature
-\ref lemon::concepts::ErasableGraph "ErasableGraph"
-concept
+\ref concepts::ErasableGraph "ErasableGraph" concept
 you can also erase individual edges and nodes in arbitrary order.
 
 The implemented graph structures are the following.
-\li \ref lemon::ListGraph "ListGraph" is the most versatile graph class. It meets
-the \ref lemon::concepts::ErasableGraph "ErasableGraph" concept
+\li \ref ListGraph is the most versatile graph class. It meets
+the \ref concepts::ErasableGraph "ErasableGraph" concept
 and it also has some convenient extra features.
-\li \ref lemon::SmartGraph "SmartGraph" is a more memory
-efficient version of \ref lemon::ListGraph "ListGraph". The
-price of this is that it only meets the
-\ref lemon::concepts::ExtendableGraph "ExtendableGraph" concept,
+\li \ref SmartGraph is a more memory efficient version of \ref ListGraph.
+The price of this is that it only meets the
+\ref concepts::ExtendableGraph "ExtendableGraph" concept,
 so you cannot delete individual edges or nodes.
-\li \ref lemon::FullGraph "FullGraph"
+\li \ref FullGraph "FullGraph"
 implements a complete graph. It is a
-\ref lemon::concepts::Graph "Graph", so you cannot
+\ref concepts::Graph "Graph", so you cannot
 change the number of nodes once it is constructed. It is extremely memory
 efficient: it uses constant amount of memory independently from the number of
@@ -58 +57 @@
 \ref maps-page "EdgeMap"'s will depend on the number of nodes.
 
-\li \ref lemon::NodeSet "NodeSet" implements a graph with no edges. This class
+\li \ref NodeSet "NodeSet" implements a graph with no edges. This class
 can be used as a base class of \ref lemon::EdgeSet "EdgeSet".
-\li \ref lemon::EdgeSet "EdgeSet" can be used to create a new graph on
+\li \ref EdgeSet "EdgeSet" can be used to create a new graph on
 the node set of another graph. The base graph can be an arbitrary graph and it
-is possible to attach several \ref lemon::EdgeSet "EdgeSet"'s to a base graph.
+is possible to attach several \ref EdgeSet "EdgeSet"'s to a base graph.
 
 \todo Don't we need SmartNodeSet and SmartEdgeSet?
@@ -121 +120 @@
 step to the next node. Using operator++ on the iterator pointing to the last
 node invalidates the iterator i.e. sets its value to
-\ref lemon::INVALID "INVALID". This is what we exploit in the stop condition.
+\ref INVALID. This is what we exploit in the stop condition.
 
 The previous code fragment prints out the following:
@@ -201 +200 @@
 
 */
+
+}
+

doc/maps1.dox

@@ -16 +16 @@
  *
  */
+
+namespace lemon {
 
 /**
@@ -35 +37 @@
 To make easy to use them - especially as template parameters - there are <i>map concepts</i> like by graph classes.
 <ul>
-<li>\ref ReadMap - values can be read out with the \c operator[].
+<li>\ref concepts::ReadMap "ReadMap" - values can be read out with the \c operator[].
 \code value_typed_variable = map_instance[key_value]; \endcode
 </li>
-<li>\ref WriteMap - values can be set with the \c set() member function.
+<li>\ref concepts::WriteMap "WriteMap" - values can be set with the \c set() member function.
 \code map_instance.set(key_value, value_typed_expression); \endcode
 </li>
-<li>\ref ReadWriteMap - it's just a shortcut to indicate that the map is both
+<li>\ref concepts::ReadWriteMap "ReadWriteMap" - it's just a shortcut to indicate that the map is both
 readable and writable. It is delivered from them.
 </li>
-<li>\ref ReferenceMap - a subclass of ReadWriteMap. It has two additional typedefs
+<li>\ref concepts::ReferenceMap "ReferenceMap" - a subclass of ReadWriteMap. It has two additional typedefs
 <i>Reference</i> and <i>ConstReference</i> and two overloads of \c operator[] to
 providing you constant or non-constant reference to the value belonging to a key,
@@ -50 +52 @@
 </li>
 <li>And there are the Matrix version of these maps, where the values are assigned to a pair of keys.
-The keys can be different types. (\ref ReadMatrixMap, \ref WriteMatrixMap, \ref ReadWriteMatrixMap, \ref ReferenceMatrixMap)
+The keys can be different types. (\ref concepts::ReadMatrixMap "ReadMatrixMap", 
+\ref concepts::WriteMatrixMap "WriteMatrixMap", \ref concepts::ReadWriteMatrixMap "ReadWriteMatrixMap",
+\ref concepts::ReferenceMatrixMap "ReferenceMatrixMap")
 </li>
 </ul>
@@ -89 +93 @@
 Or if you want to know more about maps read these \ref maps2 "advanced map techniques".
 */
+
+}

lemon/bellman_ford.h

@@ -433 +433 @@
     /// easily with \ref path() or \ref predEdge() functions. If you
     /// need the shortest path and not just the distance you should store
-    /// after each iteration the \ref predEdgeMap() map and manually build
+    /// after each iteration the \ref predMap() map and manually build
     /// the path.
     ///
@@ -546 +546 @@
     /// easily with \ref path() or \ref predEdge() functions. If you
     /// need the shortest path and not just the distance you should store
-    /// after each iteration the \ref predEdgeMap() map and manually build
+    /// after each iteration the \ref predMap() map and manually build
     /// the path.
     ///
@@ -952 +952 @@
     ///
     /// Runs BellmanFord algorithm from the given node.
-    /// \param source is the given source.
+    /// \param src is the given source.
     void run(Node src) {
       Base::_source = src;
@@ -1017 +1017 @@
     ///
     /// Sets the source node, from which the BellmanFord algorithm runs.
-    /// \param source is the source node.
+    /// \param src is the source node.
     BellmanFordWizard<_Traits>& source(Node src) {
       Base::_source = src;

lemon/bfs.h

@@ -594 +594 @@
     ///
     ///This method runs the %BFS algorithm from the root node(s)
-    ///in order to
-    ///compute the
-    ///shortest path to \c dest. The algorithm computes
+    ///in order to compute the shortest path to \c dest.
+    ///The algorithm computes
     ///- The shortest path to \c  dest.
     ///- The distance of \c dest from the root(s).
@@ -616 +615 @@
     /// <tt>nm[v]</tt> true.
     ///
-    ///\return The reached node \c v with <tt>nm[v]<\tt> true or
+    ///\return The reached node \c v with <tt>nm[v]</tt> true or
     ///\c INVALID if no such node was found.
     template<class NM>
@@ -1518 +1517 @@
     /// <tt>nm[v]</tt> true.
     ///
-    ///\return The reached node \c v with <tt>nm[v]<\tt> true or
+    ///\return The reached node \c v with <tt>nm[v]</tt> true or
     ///\c INVALID if no such node was found.
     template <typename NM>

lemon/dfs.h

@@ -565 +565 @@
     ///
     ///\param em must be a bool (or convertible) edge map. The algorithm
-    ///will stop when it reaches an edge \c e with <tt>em[e]<\tt> true.
-    ///
-    ///\return The reached edge \c e with <tt>em[e]<\tt> true or
+    ///will stop when it reaches an edge \c e with <tt>em[e]</tt> true.
+    ///
+    ///\return The reached edge \c e with <tt>em[e]</tt> true or
     ///\c INVALID if no such edge was found.
     ///
@@ -1459 +1459 @@
     ///
     /// \param em must be a bool (or convertible) edge map. The algorithm
-    /// will stop when it reaches an edge \c e with <tt>em[e]<\tt> true.
-    ///
-    ///\return The reached edge \c e with <tt>em[e]<\tt> true or
+    /// will stop when it reaches an edge \c e with <tt>em[e]</tt> true.
+    ///
+    ///\return The reached edge \c e with <tt>em[e]</tt> true or
     ///\c INVALID if no such edge was found.
     ///

lemon/dijkstra.h

@@ -666 +666 @@
     ///will stop when it reaches a node \c v with <tt>nm[v]</tt> true.
     ///
-    ///\return The reached node \c v with <tt>nm[v]<\tt> true or
+    ///\return The reached node \c v with <tt>nm[v]</tt> true or
     ///\c INVALID if no such node was found.
     template<class NodeBoolMap>

lemon/error.h

@@ -635 +635 @@
 /// behaviour will be activated. The \c msg should be either a const
 /// char* message or an exception. When the \c msg is an exception the
-/// \ref "Exception::what" what() function is called to retrieve and
+/// \ref lemon::Exception::what() "what()" function is called to retrieve and
 /// display the error message.
 ///

lemon/graph_utils.h

@@ -373 +373 @@
   ///
   ///\sa EdgeLookUp
-  ///\se AllEdgeLookUp
+  ///\sa AllEdgeLookUp
   ///\sa ConEdgeIt
   template <typename Graph>

lemon/lemon_reader.h

@@ -1129 +1129 @@
     /// It gives back true when the header line starts with \c \@edgeset,
     /// and the header line's name and the edgeset's name are the same.
-    /// The sections with @uedgeset head line could be read with this
+    /// The sections with \@uedgeset head line could be read with this
     /// section reader too.
     virtual bool header(const std::string& line) {
@@ -1438 +1438 @@
     /// It gives back true when the header line starts with \c \@uedgeset,
     /// and the header line's name and the edgeset's name are the same.
-    /// The sections with @edgeset head line could be read with this
+    /// The sections with \@edgeset head line could be read with this
     /// section reader too.
     virtual bool header(const std::string& line) {