# HG changeset patch
# User alpar
# Date 1096354858 0
# Node ID 89a4fbb99cadb52b3ead06da14dc1fed7bc28504
# Parent  5a89cacf17f10439e9069b5921c67c72d47a55bb
Fix many doxygen command bugs.

diff -r 5a89cacf17f1 -r 89a4fbb99cad doc/graphs.dox
--- a/doc/graphs.dox	Mon Sep 27 18:11:27 2004 +0000
+++ b/doc/graphs.dox	Tue Sep 28 07:00:58 2004 +0000
@@ -28,7 +28,7 @@
 
 The implemented graph structures are the following.
 \li \ref hugo::ListGraph "ListGraph" is the most versatile graph class. It meets
-the hugo::skeleton::ErasableGraph "ErasableGraph" concept
+the \ref hugo::skeleton::ErasableGraph "ErasableGraph" concept
 and it also have some convenience features.
 \li \ref hugo::SmartGraph "SmartGraph" is a more memory
 efficient version of \ref hugo::ListGraph "ListGraph". The
@@ -45,7 +45,7 @@
 attach data to the edges in such a way that the stored data
 are shared by the edge pairs. 
 \li \ref hugo::FullGraph "FullGraph"
-implements a full graph. It is a \ref ConstGraph, so you cannot
+implements a full graph. It is a \ref hugo::skeleton::StaticGraph, 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
 the nodes of the graph. Of course, the size of the \ref maps "NodeMap"'s and
diff -r 5a89cacf17f1 -r 89a4fbb99cad src/hugo/bfs.h
--- a/src/hugo/bfs.h	Mon Sep 27 18:11:27 2004 +0000
+++ b/src/hugo/bfs.h	Tue Sep 28 07:00:58 2004 +0000
@@ -49,13 +49,13 @@
   public:
     ///The type of the underlying graph.
     typedef GR Graph;
-    ///.
+    ///\e
     typedef typename Graph::Node Node;
-    ///.
+    ///\e
     typedef typename Graph::NodeIt NodeIt;
-    ///.
+    ///\e
     typedef typename Graph::Edge Edge;
-    ///.
+    ///\e
     typedef typename Graph::OutEdgeIt OutEdgeIt;
     
     ///\brief The type of the map that stores the last
@@ -108,6 +108,7 @@
     ///Constructor.
     
     ///\param _G the graph the algorithm will run on.
+    ///
     Bfs(const Graph& _G) :
       G(&_G),
       predecessor(NULL), local_predecessor(false),
diff -r 5a89cacf17f1 -r 89a4fbb99cad src/hugo/dfs.h
--- a/src/hugo/dfs.h	Mon Sep 27 18:11:27 2004 +0000
+++ b/src/hugo/dfs.h	Tue Sep 28 07:00:58 2004 +0000
@@ -48,13 +48,13 @@
   public:
     ///The type of the underlying graph.
     typedef GR Graph;
-    /// .
+    ///\e
     typedef typename Graph::Node Node;
-    /// .
+    ///\e
     typedef typename Graph::NodeIt NodeIt;
-    /// .
+    ///\e
     typedef typename Graph::Edge Edge;
-    /// .
+    ///\e
     typedef typename Graph::OutEdgeIt OutEdgeIt;
     
     ///\brief The type of the map that stores the last
@@ -107,6 +107,7 @@
     ///Constructor.
     
     ///\param _G the graph the algorithm will run on.
+    ///
     Dfs(const Graph& _G) :
       G(&_G),
       predecessor(NULL), local_predecessor(false),
diff -r 5a89cacf17f1 -r 89a4fbb99cad src/hugo/dijkstra.h
--- a/src/hugo/dijkstra.h	Mon Sep 27 18:11:27 2004 +0000
+++ b/src/hugo/dijkstra.h	Tue Sep 28 07:00:58 2004 +0000
@@ -71,13 +71,13 @@
   public:
     ///The type of the underlying graph.
     typedef GR Graph;
-    ///.
+    ///\e
     typedef typename Graph::Node Node;
-    ///.
+    ///\e
     typedef typename Graph::NodeIt NodeIt;
-    ///.
+    ///\e
     typedef typename Graph::Edge Edge;
-    ///.
+    ///\e
     typedef typename Graph::OutEdgeIt OutEdgeIt;
     
     ///The type of the length of the edges.
diff -r 5a89cacf17f1 -r 89a4fbb99cad src/hugo/fib_heap.h
--- a/src/hugo/fib_heap.h	Mon Sep 27 18:11:27 2004 +0000
+++ b/src/hugo/fib_heap.h	Tue Sep 28 07:00:58 2004 +0000
@@ -35,7 +35,7 @@
   ///This class implements the \e Fibonacci \e heap data structure. A \e heap
   ///is a data structure for storing items with specified values called \e
   ///priorities in such a way that finding the item with minimum priority is
-  ///efficient. \ref Compare specifies the ordering of the priorities. In a heap
+  ///efficient. \c Compare specifies the ordering of the priorities. In a heap
   ///one can change the priority of an item, add or erase an item, etc.
   ///
   ///The methods \ref increase and \ref erase are not efficient in a Fibonacci
@@ -117,19 +117,19 @@
     */
     void push (Item const item, PrioType const value);
     
-    ///Returns the item with minimum priority relative to \ref Compare.
+    ///Returns the item with minimum priority relative to \c Compare.
     
     /**
-       This method returns the item with minimum priority relative to \ref
+       This method returns the item with minimum priority relative to \c
        Compare.  
        \pre The heap must be nonempty.  
     */
     Item top() const { return container[minimum].name; }
 
-    ///Returns the minimum priority relative to \ref Compare.
+    ///Returns the minimum priority relative to \c Compare.
 
     /**
-       It returns the minimum priority relative to \ref Compare.
+       It returns the minimum priority relative to \c Compare.
        \pre The heap must be nonempty.
     */
     PrioType prio() const { return container[minimum].prio; }
@@ -155,10 +155,10 @@
     }
 
 
-    ///Deletes the item with minimum priority relative to \ref Compare.
+    ///Deletes the item with minimum priority relative to \c Compare.
 
     /**
-    This method deletes the item with minimum priority relative to \ref
+    This method deletes the item with minimum priority relative to \c
     Compare from the heap.  
     \pre The heap must be non-empty.  
     */
@@ -177,7 +177,7 @@
     /**
        This method decreases the priority of \c item to \c value.
        \pre \c item must be stored in the heap with priority at least \c
-       value relative to \ref Compare.
+       value relative to \c Compare.
     */
     void decrease (Item item, PrioType const value); 
 
@@ -187,7 +187,7 @@
        This method sets the priority of \c item to \c value. Though
        there is no precondition on the priority of \c item, this
        method should be used only if it is indeed necessary to increase
-       (relative to \ref Compare) the priority of \c item, because this
+       (relative to \c Compare) the priority of \c item, because this
        method is inefficient.
     */
     void increase (Item item, PrioType const value) {
diff -r 5a89cacf17f1 -r 89a4fbb99cad src/hugo/graph_wrapper.h
--- a/src/hugo/graph_wrapper.h	Mon Sep 27 18:11:27 2004 +0000
+++ b/src/hugo/graph_wrapper.h	Tue Sep 28 07:00:58 2004 +0000
@@ -605,6 +605,9 @@
   ///\brief A wrapper for composing a subgraph of a 
   /// bidirected graph made from a directed one. 
   ///
+  /// A wrapper for composing a subgraph of a 
+  /// bidirected graph made from a directed one. 
+  ///
   ///\warning Graph wrappers are in even more experimental state than the other
   ///parts of the lib. Use them at you own risk.
   ///
diff -r 5a89cacf17f1 -r 89a4fbb99cad src/hugo/list_graph.h
--- a/src/hugo/list_graph.h	Mon Sep 27 18:11:27 2004 +0000
+++ b/src/hugo/list_graph.h	Tue Sep 28 07:00:58 2004 +0000
@@ -421,16 +421,16 @@
   ///having bidirectional edges. Here the function \c addEdge(u,v) adds a pair
   ///of oppositely directed edges.
   ///There is a new edge map type called
-  ///\ref SymListGraph::SymEdgeMap "SymEdgeMap"
+  ///\ref hugo::SymListGraph::SymEdgeMap "SymEdgeMap"
   ///that complements this
   ///feature by
   ///storing shared values for the edge pairs. The usual
-  ///\ref Graph::EdgeMap "EdgeMap"
+  ///\ref hugo::skeleton::StaticGraph::EdgeMap "EdgeMap"
   ///can be used
   ///as well.
   ///
   ///The oppositely directed edge can also be obtained easily
-  ///using \ref opposite.
+  ///using \ref hugo::SymListGraph::opposite() "opposite()" member function.
   ///
   ///Here erase(Edge) deletes a pair of edges.
   ///
diff -r 5a89cacf17f1 -r 89a4fbb99cad src/hugo/maps.h
--- a/src/hugo/maps.h	Mon Sep 27 18:11:27 2004 +0000
+++ b/src/hugo/maps.h	Tue Sep 28 07:00:58 2004 +0000
@@ -35,9 +35,9 @@
   class MapBase
   {
   public:
-    /// .
+    ///\e
     typedef K KeyType;
-    /// .
+    ///\e
     typedef T ValueType;
   };
 
@@ -74,9 +74,10 @@
     /// The value of the map will be uninitialized. 
     /// (More exactly it will be default constructed.)
     ConstMap() {}
-    /// .
+    ///\e
 
     /// \param _v The initial value of the map.
+    ///
     ConstMap(const T &_v) : v(_v) {}
 
     T operator[](const K&) const { return v; }
diff -r 5a89cacf17f1 -r 89a4fbb99cad src/hugo/preflow.h
--- a/src/hugo/preflow.h	Mon Sep 27 18:11:27 2004 +0000
+++ b/src/hugo/preflow.h	Tue Sep 28 07:00:58 2004 +0000
@@ -44,7 +44,8 @@
   ///functions \ref setSource, \ref setTarget, \ref setCap and \ref
   ///setFlow.
   ///
-  ///After running \ref phase1() or \ref preflow(), the actual flow
+  ///After running \ref hugo::Preflow::phase1() "phase1()"
+  ///or \ref hugo::Preflow::run() "run()", the actual flow
   ///value can be obtained by calling \ref flowValue(). The minimum
   ///value cut can be written into a <tt>bool</tt> node map by
   ///calling \ref minCut(). (\ref minMinCut() and \ref maxMinCut() writes
@@ -96,8 +97,9 @@
     ///the \e target.
     ///- \c PRE_FLOW: any preflow, i.e. the sum of the in-flows is at 
     ///least the sum of the out-flows in every node except the \e source.
-    ///- \c NO_FLOW: indicates an unspecified edge map. \ref flow will be 
-    ///set to the constant zero flow in the beginning of the algorithm in this case.
+    ///- \c NO_FLOW: indicates an unspecified edge map. \c flow will be 
+    ///set to the constant zero flow in the beginning of
+    ///the algorithm in this case.
     ///
     enum FlowEnum{
       NO_FLOW,
@@ -194,9 +196,9 @@
     ///first phase. After the first phase the maximum flow value and a
     ///minimum value cut can already be computed, though a maximum flow
     ///is not yet obtained. So after calling this method \ref flowValue
-    ///and \ref actMinCut gives proper results.
-    ///\warning \ref minCut, \ref minMinCut and \ref maxMinCut do not
-    ///give minimum value cuts unless calling \ref phase2.
+    ///and \ref MinCut() gives proper results.
+    ///\warning \ref minCut(), \ref minMinCut() and \ref maxMinCut() do not
+    ///give minimum value cuts unless calling \ref phase2().
     void phase1()
     {
       int heur0=(int)(H0*n);  //time while running 'bound decrease'
@@ -349,7 +351,7 @@
     /// Returns the value of the maximum flow.
 
     /// Returns the value of the maximum flow by returning the excess
-    /// of the target node \ref t. This value equals to the value of
+    /// of the target node \c t. This value equals to the value of
     /// the maximum flow already after running \ref phase1.
     Num flowValue() const {
       return excess[t];
@@ -362,7 +364,7 @@
     ///cut. This method can be called both after running \ref
     ///phase1 and \ref phase2. It is much faster after
     ///\ref phase1.  \pre M should be a bool-valued node-map. \pre
-    ///If \ref mincut is called after \ref phase2 then M should
+    ///If \ref minCut() is called after \ref phase2() then M should
     ///be initialized to false.
     template<typename _CutMap>
     void minCut(_CutMap& M) const {
@@ -425,7 +427,7 @@
     ///Sets \c M to the characteristic vector of the minimum value cut
     ///which is inclusionwise maximum. It is computed by processing a
     ///backward bfs from the target node \c t in the residual graph.
-    ///\pre \ref phase2() or preflow() should already be run.
+    ///\pre \ref phase2() or run() should already be run.
     template<typename _CutMap>
     void maxMinCut(_CutMap& M) const {
 
diff -r 5a89cacf17f1 -r 89a4fbb99cad src/hugo/skeletons/graph.h
--- a/src/hugo/skeletons/graph.h	Mon Sep 27 18:11:27 2004 +0000
+++ b/src/hugo/skeletons/graph.h	Tue Sep 28 07:00:58 2004 +0000
@@ -92,7 +92,7 @@
 
 	/// Inequality operator
 	
-	/// \sa \ref operator==(Node n)
+	/// \sa operator==(Node n)
 	///
 	bool operator!=(Node) const { return true; }
 
@@ -180,7 +180,7 @@
 	bool operator==(Edge) const { return true; }
 	/// Inequality operator
 
-	/// \sa \ref operator==(Node n)
+	/// \sa operator==(Node n)
 	///
 	bool operator!=(Edge) const { return true; }
  	///Comparison operator.
@@ -382,12 +382,12 @@
       ///\todo Should each graph provide \c id?
       int id(const Edge&) const { return 0; }
 
-      /// .
+      ///\e
       
       ///\todo Should it be in the concept?
       ///
       int nodeNum() const { return 0; }
-      /// .
+      ///\e
 
       ///\todo Should it be in the concept?
       ///
@@ -405,9 +405,9 @@
       {
       public:
 
-	/// .
+	///\e
 	NodeMap(const StaticGraph&) { }
-	/// .
+	///\e
 	NodeMap(const StaticGraph&, T) { }
 
 	///Copy constructor
@@ -429,9 +429,9 @@
       {
       public:
 
-	/// .
+	///\e
 	EdgeMap(const StaticGraph&) { }
-	/// .
+	///\e
 	EdgeMap(const StaticGraph&, T) { }
     
 	///Copy constructor
diff -r 5a89cacf17f1 -r 89a4fbb99cad src/hugo/skeletons/sym_graph.h
--- a/src/hugo/skeletons/sym_graph.h	Mon Sep 27 18:11:27 2004 +0000
+++ b/src/hugo/skeletons/sym_graph.h	Tue Sep 28 07:00:58 2004 +0000
@@ -45,7 +45,7 @@
     /// Also, you will find here the full documentation of a certain graph
     /// feature, the documentation of a real symmetric graph imlementation
     /// like @ref SymListGraph or
-    /// @ref SymSmartGraph will just refer to this structure.
+    /// @ref hugo::SymSmartGraph will just refer to this structure.
     class StaticSymGraph
     {
     public:
@@ -93,7 +93,7 @@
 
 	/// Inequality operator
 	
-	/// \sa \ref operator==(Node n)
+	/// \sa operator==(Node n)
 	///
 	bool operator!=(Node) const { return true; }
 
@@ -181,7 +181,7 @@
 	bool operator==(SymEdge) const { return true; }
 	/// Inequality operator
 
-	/// \sa \ref operator==(Node n)
+	/// \sa operator==(Node n)
 	///
 	bool operator!=(SymEdge) const { return true; }
  	///Comparison operator.
@@ -223,7 +223,7 @@
 	bool operator==(Edge) const { return true; }
 	/// Inequality operator
 
-	/// \sa \ref operator==(Node n)
+	/// \sa operator==(Node n)
 	///
 	bool operator!=(Edge) const { return true; }
  	///Comparison operator.
@@ -489,12 +489,12 @@
       ///\todo Should each graph provide \c id?
       int id(const SymEdge&) const { return 0; }
 
-      /// .
+      ///\e
       
       ///\todo Should it be in the concept?
       ///
       int nodeNum() const { return 0; }
-      /// .
+      ///\e
 
       ///\todo Should it be in the concept?
       ///
@@ -524,9 +524,9 @@
       {
       public:
 
-	/// .
+	///\e
 	NodeMap(const StaticSymGraph&) { }
-	/// .
+	///\e
 	NodeMap(const StaticSymGraph&, T) { }
 
 	///Copy constructor
@@ -548,9 +548,9 @@
       {
       public:
 
-	/// .
+	///\e
 	EdgeMap(const StaticSymGraph&) { }
-	/// .
+	///\e
 	EdgeMap(const StaticSymGraph&, T) { }
     
 	///Copy constructor
@@ -572,9 +572,9 @@
       {
       public:
 
-	/// .
+	///\e
 	SymEdgeMap(const StaticSymGraph&) { }
-	/// .
+	///\e
 	SymEdgeMap(const StaticSymGraph&, T) { }
     
 	///Copy constructor