Index: lemon/bin_heap.h
===================================================================
--- lemon/bin_heap.h	(revision 631)
+++ lemon/bin_heap.h	(revision 606)
@@ -74,7 +74,7 @@
     /// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap.
     enum State {
-      IN_HEAP = 0,    ///< = 0.
-      PRE_HEAP = -1,  ///< = -1.
-      POST_HEAP = -2  ///< = -2.
+      IN_HEAP = 0,    ///< \e
+      PRE_HEAP = -1,  ///< \e
+      POST_HEAP = -2  ///< \e
     };
 
Index: lemon/concepts/graph_components.h
===================================================================
--- lemon/concepts/graph_components.h	(revision 631)
+++ lemon/concepts/graph_components.h	(revision 627)
@@ -603,5 +603,5 @@
       typedef IterableDigraphComponent Digraph;
 
-      /// \name Base Iteration
+      /// \name Base iteration
       ///
       /// This interface provides functions for iteration on digraph items.
@@ -655,5 +655,5 @@
       /// @}
 
-      /// \name Class Based Iteration
+      /// \name Class based iteration
       ///
       /// This interface provides iterator classes for digraph items.
@@ -780,5 +780,5 @@
       typedef IterableGraphComponent Graph;
 
-      /// \name Base Iteration
+      /// \name Base iteration
       ///
       /// This interface provides functions for iteration on edges.
@@ -819,5 +819,5 @@
       /// @}
 
-      /// \name Class Based Iteration
+      /// \name Class based iteration
       ///
       /// This interface provides iterator classes for edges.
Index: lemon/concepts/heap.h
===================================================================
--- lemon/concepts/heap.h	(revision 631)
+++ lemon/concepts/heap.h	(revision 606)
@@ -72,7 +72,7 @@
       /// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap.
       enum State {
-        IN_HEAP = 0,    ///< = 0. The "in heap" state constant.
-        PRE_HEAP = -1,  ///< = -1. The "pre heap" state constant.
-        POST_HEAP = -2  ///< = -2. The "post heap" state constant.
+        IN_HEAP = 0,    ///< The "in heap" state constant.
+        PRE_HEAP = -1,  ///< The "pre heap" state constant.
+        POST_HEAP = -2  ///< The "post heap" state constant.
       };
 
Index: lemon/dfs.h
===================================================================
--- lemon/dfs.h	(revision 631)
+++ lemon/dfs.h	(revision 525)
@@ -207,5 +207,5 @@
     typedef Dfs Create;
 
-    ///\name Named Template Parameters
+    ///\name Named template parameters
 
     ///@{
Index: lemon/dijkstra.h
===================================================================
--- lemon/dijkstra.h	(revision 631)
+++ lemon/dijkstra.h	(revision 606)
@@ -287,5 +287,5 @@
     typedef Dijkstra Create;
 
-    ///\name Named Template Parameters
+    ///\name Named template parameters
 
     ///@{
Index: lemon/dimacs.h
===================================================================
--- lemon/dimacs.h	(revision 631)
+++ lemon/dimacs.h	(revision 608)
@@ -38,14 +38,9 @@
   struct DimacsDescriptor
   {
-    ///\brief DIMACS file type enum
-    ///
-    ///DIMACS file type enum.
-    enum Type {
-      NONE,  ///< Undefined type.
-      MIN,   ///< DIMACS file type for minimum cost flow problems.
-      MAX,   ///< DIMACS file type for maximum flow problems.
-      SP,    ///< DIMACS file type for shostest path problems.
-      MAT    ///< DIMACS file type for plain graphs and matching problems.
-    };
+    ///File type enum
+    enum Type
+      {
+        NONE, MIN, MAX, SP, MAT
+      };
     ///The file type
     Type type;
@@ -55,5 +50,5 @@
     int edgeNum;
     int lineShift;
-    ///Constructor. It sets the type to \c NONE.
+    /// Constructor. Sets the type to NONE.
     DimacsDescriptor() : type(NONE) {}
   };
@@ -61,8 +56,8 @@
   ///Discover the type of a DIMACS file
 
-  ///This function starts seeking the beginning of the given file for the
-  ///problem type and size info. 
-  ///The found data is returned in a special struct that can be evaluated
-  ///and passed to the appropriate reader function.
+  ///It starts seeking the beginning of the file for the problem type
+  ///and size info. The found data is returned in a special struct
+  ///that can be evaluated and passed to the appropriate reader
+  ///function.
   DimacsDescriptor dimacsType(std::istream& is)
   {
@@ -102,5 +97,6 @@
 
 
-  /// \brief DIMACS minimum cost flow reader function.
+
+  /// DIMACS minimum cost flow reader function.
   ///
   /// This function reads a minimum cost flow instance from DIMACS format,
@@ -258,5 +254,5 @@
   }
 
-  /// \brief DIMACS maximum flow reader function.
+  /// DIMACS maximum flow reader function.
   ///
   /// This function reads a maximum flow instance from DIMACS format,
@@ -292,5 +288,5 @@
   }
 
-  /// \brief DIMACS shortest path reader function.
+  /// DIMACS shortest path reader function.
   ///
   /// This function reads a shortest path instance from DIMACS format,
@@ -318,5 +314,5 @@
   }
 
-  /// \brief DIMACS capacitated digraph reader function.
+  /// DIMACS capacitated digraph reader function.
   ///
   /// This function reads an arc capacitated digraph instance from
@@ -364,9 +360,9 @@
   }
   
-  /// \brief DIMACS plain (di)graph reader function.
-  ///
-  /// This function reads a plain (di)graph without any designated nodes
-  /// and maps (e.g. a matching instance) from DIMACS format, i.e. from 
-  /// DIMACS files having a line starting with
+  /// DIMACS plain (di)graph reader function.
+  ///
+  /// This function reads a (di)graph without any designated nodes and
+  /// maps from DIMACS format, i.e. from DIMACS files having a line
+  /// starting with
   /// \code
   ///   p mat
Index: lemon/graph_to_eps.h
===================================================================
--- lemon/graph_to_eps.h	(revision 631)
+++ lemon/graph_to_eps.h	(revision 606)
@@ -269,16 +269,20 @@
     ///\image html nodeshape_1.png
     ///\image latex nodeshape_1.eps "SQUARE shape (1)" width=2cm
+    ///
     SQUARE=1,
     /// = 2
     ///\image html nodeshape_2.png
     ///\image latex nodeshape_2.eps "DIAMOND shape (2)" width=2cm
+    ///
     DIAMOND=2,
     /// = 3
     ///\image html nodeshape_3.png
-    ///\image latex nodeshape_3.eps "MALE shape (3)" width=2cm
+    ///\image latex nodeshape_2.eps "MALE shape (4)" width=2cm
+    ///
     MALE=3,
     /// = 4
     ///\image html nodeshape_4.png
-    ///\image latex nodeshape_4.eps "FEMALE shape (4)" width=2cm
+    ///\image latex nodeshape_2.eps "FEMALE shape (4)" width=2cm
+    ///
     FEMALE=4
   };
Index: lemon/kruskal.h
===================================================================
--- lemon/kruskal.h	(revision 631)
+++ lemon/kruskal.h	(revision 463)
@@ -249,9 +249,9 @@
   /// \ingroup spantree
   ///
-  /// \brief Kruskal's algorithm for finding a minimum cost spanning tree of
+  /// \brief Kruskal algorithm to find a minimum cost spanning tree of
   /// a graph.
   ///
   /// This function runs Kruskal's algorithm to find a minimum cost
-  /// spanning tree of a graph.
+  /// spanning tree.
   /// Due to some C++ hacking, it accepts various input and output types.
   ///
@@ -265,7 +265,7 @@
   /// It can be one of the following choices.
   /// - An STL compatible 'Forward Container' with
-  /// <tt>std::pair<GR::Arc,C></tt> or
-  /// <tt>std::pair<GR::Edge,C></tt> as its <tt>value_type</tt>, where
-  /// \c C is the type of the costs. The pairs indicates the arcs/edges
+  /// <tt>std::pair<GR::Arc,X></tt> or
+  /// <tt>std::pair<GR::Edge,X></tt> as its <tt>value_type</tt>, where
+  /// \c X is the type of the costs. The pairs indicates the arcs/edges
   /// along with the assigned cost. <em>They must be in a
   /// cost-ascending order.</em>
@@ -274,6 +274,6 @@
   ///
   /// \retval out Here we also have a choice.
-  /// - It can be a writable arc/edge map with \c bool value type. After
-  /// running the algorithm it will contain the found minimum cost spanning
+  /// - It can be a writable \c bool arc/edge map. After running the
+  /// algorithm it will contain the found minimum cost spanning
   /// tree: the value of an arc/edge will be set to \c true if it belongs
   /// to the tree, otherwise it will be set to \c false. The value of
@@ -302,6 +302,6 @@
 
 #ifdef DOXYGEN
-  template <typename Graph, typename In, typename Out>
-  Value kruskal(const Graph& g, const In& in, Out& out)
+  template <class Graph, class In, class Out>
+  Value kruskal(GR const& g, const In& in, Out& out)
 #else
   template <class Graph, class In, class Out>
@@ -315,4 +315,6 @@
 
 
+
+
   template <class Graph, class In, class Out>
   inline typename _kruskal_bits::KruskalValueSelector<In>::Value
Index: lemon/lgf_reader.h
===================================================================
--- lemon/lgf_reader.h	(revision 631)
+++ lemon/lgf_reader.h	(revision 606)
@@ -594,5 +594,5 @@
   public:
 
-    /// \name Reading Rules
+    /// \name Reading rules
     /// @{
 
@@ -699,5 +699,5 @@
     /// @}
 
-    /// \name Select Section by Name
+    /// \name Select section by name
     /// @{
 
@@ -728,5 +728,5 @@
     /// @}
 
-    /// \name Using Previously Constructed Node or Arc Set
+    /// \name Using previously constructed node or arc set
     /// @{
 
@@ -1117,5 +1117,5 @@
   public:
 
-    /// \name Execution of the Reader
+    /// \name Execution of the reader
     /// @{
 
@@ -1390,5 +1390,5 @@
   public:
 
-    /// \name Reading Rules
+    /// \name Reading rules
     /// @{
 
@@ -1541,5 +1541,5 @@
     /// @}
 
-    /// \name Select Section by Name
+    /// \name Select section by name
     /// @{
 
@@ -1570,5 +1570,5 @@
     /// @}
 
-    /// \name Using Previously Constructed Node or Edge Set
+    /// \name Using previously constructed node or edge set
     /// @{
 
@@ -1960,5 +1960,5 @@
   public:
 
-    /// \name Execution of the Reader
+    /// \name Execution of the reader
     /// @{
 
@@ -2159,5 +2159,5 @@
   public:
 
-    /// \name Section Readers
+    /// \name Section readers
     /// @{
 
@@ -2258,5 +2258,5 @@
 
 
-    /// \name Execution of the Reader
+    /// \name Execution of the reader
     /// @{
 
@@ -2440,5 +2440,5 @@
 
 
-    /// \name Node Sections
+    /// \name Node sections
     /// @{
 
@@ -2466,5 +2466,5 @@
     /// @}
 
-    /// \name Arc/Edge Sections
+    /// \name Arc/Edge sections
     /// @{
 
@@ -2524,5 +2524,5 @@
     /// @}
 
-    /// \name Attribute Sections
+    /// \name Attribute sections
     /// @{
 
@@ -2550,5 +2550,5 @@
     /// @}
 
-    /// \name Extra Sections
+    /// \name Extra sections
     /// @{
 
@@ -2626,5 +2626,5 @@
   public:
 
-    /// \name Execution of the Contents Reader
+    /// \name Execution of the contents reader
     /// @{
 
Index: lemon/lgf_writer.h
===================================================================
--- lemon/lgf_writer.h	(revision 631)
+++ lemon/lgf_writer.h	(revision 606)
@@ -539,5 +539,5 @@
   public:
 
-    /// \name Writing Rules
+    /// \name Writing rules
     /// @{
 
@@ -642,5 +642,5 @@
     }
 
-    /// \name Section Captions
+    /// \name Section captions
     /// @{
 
@@ -669,5 +669,5 @@
     }
 
-    /// \name Skipping Section
+    /// \name Skipping section
     /// @{
 
@@ -886,5 +886,5 @@
   public:
 
-    /// \name Execution of the Writer
+    /// \name Execution of the writer
     /// @{
 
@@ -1107,5 +1107,5 @@
   public:
 
-    /// \name Writing Rules
+    /// \name Writing rules
     /// @{
 
@@ -1256,5 +1256,5 @@
     }
 
-    /// \name Section Captions
+    /// \name Section captions
     /// @{
 
@@ -1283,5 +1283,5 @@
     }
 
-    /// \name Skipping Section
+    /// \name Skipping section
     /// @{
 
@@ -1500,5 +1500,5 @@
   public:
 
-    /// \name Execution of the Writer
+    /// \name Execution of the writer
     /// @{
 
@@ -1652,5 +1652,5 @@
   public:
 
-    /// \name Section Writers
+    /// \name Section writers
     /// @{
 
@@ -1719,5 +1719,5 @@
 
 
-    /// \name Execution of the Writer
+    /// \name Execution of the writer
     /// @{
 
Index: lemon/lp_base.h
===================================================================
--- lemon/lp_base.h	(revision 631)
+++ lemon/lp_base.h	(revision 623)
@@ -53,10 +53,10 @@
     ///Possible outcomes of an LP solving procedure
     enum SolveExitStatus {
-      /// = 0. It means that the problem has been successfully solved: either
+      ///This means that the problem has been successfully solved: either
       ///an optimal solution has been found or infeasibility/unboundedness
       ///has been proved.
       SOLVED = 0,
-      /// = 1. Any other case (including the case when some user specified
-      ///limit has been exceeded).
+      ///Any other case (including the case when some user specified
+      ///limit has been exceeded)
       UNSOLVED = 1
     };
@@ -72,13 +72,13 @@
     ///Enum for \c messageLevel() parameter
     enum MessageLevel {
-      /// No output (default value).
+      /// no output (default value)
       MESSAGE_NOTHING,
-      /// Error messages only.
+      /// error messages only
       MESSAGE_ERROR,
-      /// Warnings.
+      /// warnings
       MESSAGE_WARNING,
-      /// Normal output.
+      /// normal output
       MESSAGE_NORMAL,
-      /// Verbose output.
+      /// verbose output
       MESSAGE_VERBOSE
     };
@@ -1006,5 +1006,5 @@
     const char* solverName() const {return _solverName();}
 
-    ///\name Build Up and Modify the LP
+    ///\name Build up and modify the LP
 
     ///@{
@@ -1789,13 +1789,13 @@
     /// The problem types for primal and dual problems
     enum ProblemType {
-      /// = 0. Feasible solution hasn't been found (but may exist).
+      ///Feasible solution hasn't been found (but may exist).
       UNDEFINED = 0,
-      /// = 1. The problem has no feasible solution.
+      ///The problem has no feasible solution
       INFEASIBLE = 1,
-      /// = 2. Feasible solution found.
+      ///Feasible solution found
       FEASIBLE = 2,
-      /// = 3. Optimal solution exists and found.
+      ///Optimal solution exists and found
       OPTIMAL = 3,
-      /// = 4. The cost function is unbounded.
+      ///The cost function is unbounded
       UNBOUNDED = 4
     };
@@ -1853,5 +1853,5 @@
     ///@}
 
-    ///\name Obtain the Solution
+    ///\name Obtain the solution
 
     ///@{
@@ -1975,14 +1975,15 @@
     /// The problem types for MIP problems
     enum ProblemType {
-      /// = 0. Feasible solution hasn't been found (but may exist).
+      ///Feasible solution hasn't been found (but may exist).
       UNDEFINED = 0,
-      /// = 1. The problem has no feasible solution.
+      ///The problem has no feasible solution
       INFEASIBLE = 1,
-      /// = 2. Feasible solution found.
+      ///Feasible solution found
       FEASIBLE = 2,
-      /// = 3. Optimal solution exists and found.
+      ///Optimal solution exists and found
       OPTIMAL = 3,
-      /// = 4. The cost function is unbounded.
-      ///The Mip or at least the relaxed problem is unbounded.
+      ///The cost function is unbounded
+      ///
+      ///The Mip or at least the relaxed problem is unbounded
       UNBOUNDED = 4
     };
@@ -2006,12 +2007,12 @@
     ///@}
 
-    ///\name Set Column Type
+    ///\name Setting column type
     ///@{
 
     ///Possible variable (column) types (e.g. real, integer, binary etc.)
     enum ColTypes {
-      /// = 0. Continuous variable (default).
+      ///Continuous variable (default)
       REAL = 0,
-      /// = 1. Integer variable.
+      ///Integer variable
       INTEGER = 1
     };
@@ -2034,5 +2035,5 @@
     ///@}
 
-    ///\name Obtain the Solution
+    ///\name Obtain the solution
 
     ///@{
Index: lemon/maps.h
===================================================================
--- lemon/maps.h	(revision 631)
+++ lemon/maps.h	(revision 619)
@@ -2729,6 +2729,6 @@
   /// \brief Potential difference map
   ///
-  /// PotentialDifferenceMap returns the difference between the potentials of
-  /// the source and target nodes of each arc in a digraph, i.e. it returns
+  /// PotentialMap returns the difference between the potentials of the
+  /// source and target nodes of each arc in a digraph, i.e. it returns
   /// \code
   ///   potential[gr.target(arc)] - potential[gr.source(arc)].
Index: lemon/min_cost_arborescence.h
===================================================================
--- lemon/min_cost_arborescence.h	(revision 631)
+++ lemon/min_cost_arborescence.h	(revision 628)
@@ -91,8 +91,8 @@
   /// \ingroup spantree
   ///
-  /// \brief Minimum Cost Arborescence algorithm class.
+  /// \brief %MinCostArborescence algorithm class.
   ///
   /// This class provides an efficient implementation of
-  /// Minimum Cost Arborescence algorithm. The arborescence is a tree
+  /// %MinCostArborescence algorithm. The arborescence is a tree
   /// which is directed from a given source node of the digraph. One or
   /// more sources should be given for the algorithm and it will calculate
@@ -391,5 +391,5 @@
   public:
 
-    /// \name Named Template Parameters
+    /// \name Named template parameters
 
     /// @{
@@ -631,5 +631,5 @@
     /// @}
 
-    /// \name Execution Control
+    /// \name Execution control
     /// The simplest way to execute the algorithm is to use
     /// one of the member functions called \c run(...). \n
Index: lemon/random.h
===================================================================
--- lemon/random.h	(revision 631)
+++ lemon/random.h	(revision 606)
@@ -660,5 +660,5 @@
     /// @}
 
-    ///\name Uniform Distributions
+    ///\name Uniform distributions
     ///
     /// @{
@@ -763,5 +763,5 @@
     /// @}
 
-    ///\name Non-uniform Distributions
+    ///\name Non-uniform distributions
     ///
     ///@{
@@ -939,5 +939,5 @@
     ///@}
 
-    ///\name Two Dimensional Distributions
+    ///\name Two dimensional distributions
     ///
     ///@{
Index: lemon/suurballe.h
===================================================================
--- lemon/suurballe.h	(revision 631)
+++ lemon/suurballe.h	(revision 606)
@@ -289,5 +289,5 @@
     }
 
-    /// \name Execution Control
+    /// \name Execution control
     /// The simplest way to execute the algorithm is to call the run()
     /// function.
Index: lemon/time_measure.h
===================================================================
--- lemon/time_measure.h	(revision 631)
+++ lemon/time_measure.h	(revision 595)
@@ -288,5 +288,5 @@
     Timer(bool run=true) :_running(run) {_reset();}
 
-    ///\name Control the State of the Timer
+    ///\name Control the state of the timer
     ///Basically a Timer can be either running or stopped,
     ///but it provides a bit finer control on the execution.
@@ -396,5 +396,5 @@
     ///@}
 
-    ///\name Query Functions for the Ellapsed Time
+    ///\name Query Functions for the ellapsed time
 
     ///@{
Index: test/bfs_test.cc
===================================================================
--- test/bfs_test.cc	(revision 463)
+++ test/bfs_test.cc	(revision 632)
@@ -59,14 +59,16 @@
 
   Digraph G;
-  Node s, t;
+  Node s, t, n;
   Arc e;
-  int l;
+  int l, i;
   bool b;
   BType::DistMap d(G);
   BType::PredMap p(G);
   Path<Digraph> pp;
+  concepts::ReadMap<Node,bool> nm;
 
   {
     BType bfs_test(G);
+    const BType& const_bfs_test = bfs_test;
 
     bfs_test.run(s);
@@ -74,11 +76,24 @@
     bfs_test.run();
 
-    l  = bfs_test.dist(t);
-    e  = bfs_test.predArc(t);
-    s  = bfs_test.predNode(t);
-    b  = bfs_test.reached(t);
-    d  = bfs_test.distMap();
-    p  = bfs_test.predMap();
-    pp = bfs_test.path(t);
+    bfs_test.init();
+    bfs_test.addSource(s);
+    n = bfs_test.processNextNode();
+    n = bfs_test.processNextNode(t, b);
+    n = bfs_test.processNextNode(nm, n);
+    n = const_bfs_test.nextNode();
+    b = const_bfs_test.emptyQueue();
+    i = const_bfs_test.queueSize();
+    
+    bfs_test.start();
+    bfs_test.start(t);
+    bfs_test.start(nm);
+
+    l  = const_bfs_test.dist(t);
+    e  = const_bfs_test.predArc(t);
+    s  = const_bfs_test.predNode(t);
+    b  = const_bfs_test.reached(t);
+    d  = const_bfs_test.distMap();
+    p  = const_bfs_test.predMap();
+    pp = const_bfs_test.path(t);
   }
   {
@@ -87,11 +102,35 @@
       ::SetDistMap<concepts::ReadWriteMap<Node,int> >
       ::SetReachedMap<concepts::ReadWriteMap<Node,bool> >
+      ::SetStandardProcessedMap
       ::SetProcessedMap<concepts::WriteMap<Node,bool> >
-      ::SetStandardProcessedMap
       ::Create bfs_test(G);
+      
+    concepts::ReadWriteMap<Node,Arc> pred_map;
+    concepts::ReadWriteMap<Node,int> dist_map;
+    concepts::ReadWriteMap<Node,bool> reached_map;
+    concepts::WriteMap<Node,bool> processed_map;
+    
+    bfs_test
+      .predMap(pred_map)
+      .distMap(dist_map)
+      .reachedMap(reached_map)
+      .processedMap(processed_map);
 
     bfs_test.run(s);
     bfs_test.run(s,t);
     bfs_test.run();
+    
+    bfs_test.init();
+    bfs_test.addSource(s);
+    n = bfs_test.processNextNode();
+    n = bfs_test.processNextNode(t, b);
+    n = bfs_test.processNextNode(nm, n);
+    n = bfs_test.nextNode();
+    b = bfs_test.emptyQueue();
+    i = bfs_test.queueSize();
+    
+    bfs_test.start();
+    bfs_test.start(t);
+    bfs_test.start(nm);
 
     l  = bfs_test.dist(t);
Index: test/circulation_test.cc
===================================================================
--- test/circulation_test.cc	(revision 463)
+++ test/circulation_test.cc	(revision 632)
@@ -72,16 +72,20 @@
   FlowMap flow;
   BarrierMap bar;
+  VType v;
+  bool b;
 
-  Circulation<Digraph, CapMap, CapMap, DeltaMap>
-    ::SetFlowMap<FlowMap>
-    ::SetElevator<Elev>
-    ::SetStandardElevator<LinkedElev>
-    ::Create circ_test(g,lcap,ucap,delta);
-
-  circ_test.lowerCapMap(lcap);
-  circ_test.upperCapMap(ucap);
-  circ_test.deltaMap(delta);
-  flow = circ_test.flowMap();
-  circ_test.flowMap(flow);
+  typedef Circulation<Digraph, CapMap, CapMap, DeltaMap>
+            ::SetFlowMap<FlowMap>
+            ::SetElevator<Elev>
+            ::SetStandardElevator<LinkedElev>
+            ::Create CirculationType;
+  CirculationType circ_test(g, lcap, ucap, delta);
+  const CirculationType& const_circ_test = circ_test;
+   
+  circ_test
+    .lowerCapMap(lcap)
+    .upperCapMap(ucap)
+    .deltaMap(delta)
+    .flowMap(flow);
 
   circ_test.init();
@@ -90,7 +94,10 @@
   circ_test.run();
 
-  circ_test.barrier(n);
-  circ_test.barrierMap(bar);
-  circ_test.flow(a);
+  v = const_circ_test.flow(a);
+  const FlowMap& fm = const_circ_test.flowMap();
+  b = const_circ_test.barrier(n);
+  const_circ_test.barrierMap(bar);
+  
+  ignore_unused_variable_warning(fm);
 }
 
Index: test/dfs_test.cc
===================================================================
--- test/dfs_test.cc	(revision 463)
+++ test/dfs_test.cc	(revision 632)
@@ -63,12 +63,14 @@
   Node s, t;
   Arc e;
-  int l;
+  int l, i;
   bool b;
   DType::DistMap d(G);
   DType::PredMap p(G);
   Path<Digraph> pp;
+  concepts::ReadMap<Arc,bool> am;
 
   {
     DType dfs_test(G);
+    const DType& const_dfs_test = dfs_test;
 
     dfs_test.run(s);
@@ -76,11 +78,22 @@
     dfs_test.run();
 
-    l  = dfs_test.dist(t);
-    e  = dfs_test.predArc(t);
-    s  = dfs_test.predNode(t);
-    b  = dfs_test.reached(t);
-    d  = dfs_test.distMap();
-    p  = dfs_test.predMap();
-    pp = dfs_test.path(t);
+    dfs_test.init();
+    dfs_test.addSource(s);
+    e = dfs_test.processNextArc();
+    e = const_dfs_test.nextArc();
+    b = const_dfs_test.emptyQueue();
+    i = const_dfs_test.queueSize();
+    
+    dfs_test.start();
+    dfs_test.start(t);
+    dfs_test.start(am);
+
+    l  = const_dfs_test.dist(t);
+    e  = const_dfs_test.predArc(t);
+    s  = const_dfs_test.predNode(t);
+    b  = const_dfs_test.reached(t);
+    d  = const_dfs_test.distMap();
+    p  = const_dfs_test.predMap();
+    pp = const_dfs_test.path(t);
   }
   {
@@ -89,11 +102,33 @@
       ::SetDistMap<concepts::ReadWriteMap<Node,int> >
       ::SetReachedMap<concepts::ReadWriteMap<Node,bool> >
+      ::SetStandardProcessedMap
       ::SetProcessedMap<concepts::WriteMap<Node,bool> >
-      ::SetStandardProcessedMap
       ::Create dfs_test(G);
+
+    concepts::ReadWriteMap<Node,Arc> pred_map;
+    concepts::ReadWriteMap<Node,int> dist_map;
+    concepts::ReadWriteMap<Node,bool> reached_map;
+    concepts::WriteMap<Node,bool> processed_map;
+    
+    dfs_test
+      .predMap(pred_map)
+      .distMap(dist_map)
+      .reachedMap(reached_map)
+      .processedMap(processed_map);
 
     dfs_test.run(s);
     dfs_test.run(s,t);
     dfs_test.run();
+    dfs_test.init();
+
+    dfs_test.addSource(s);
+    e = dfs_test.processNextArc();
+    e = dfs_test.nextArc();
+    b = dfs_test.emptyQueue();
+    i = dfs_test.queueSize();
+    
+    dfs_test.start();
+    dfs_test.start(t);
+    dfs_test.start(am);
 
     l  = dfs_test.dist(t);
Index: test/dijkstra_test.cc
===================================================================
--- test/dijkstra_test.cc	(revision 463)
+++ test/dijkstra_test.cc	(revision 632)
@@ -61,7 +61,8 @@
 
   Digraph G;
-  Node s, t;
+  Node s, t, n;
   Arc e;
   VType l;
+  int i;
   bool b;
   DType::DistMap d(G);
@@ -69,10 +70,75 @@
   LengthMap length;
   Path<Digraph> pp;
+  concepts::ReadMap<Node,bool> nm;
 
   {
     DType dijkstra_test(G,length);
+    const DType& const_dijkstra_test = dijkstra_test;
 
     dijkstra_test.run(s);
     dijkstra_test.run(s,t);
+
+    dijkstra_test.init();
+    dijkstra_test.addSource(s);
+    dijkstra_test.addSource(s, 1);
+    n = dijkstra_test.processNextNode();
+    n = const_dijkstra_test.nextNode();
+    b = const_dijkstra_test.emptyQueue();
+    i = const_dijkstra_test.queueSize();
+    
+    dijkstra_test.start();
+    dijkstra_test.start(t);
+    dijkstra_test.start(nm);
+
+    l  = const_dijkstra_test.dist(t);
+    e  = const_dijkstra_test.predArc(t);
+    s  = const_dijkstra_test.predNode(t);
+    b  = const_dijkstra_test.reached(t);
+    b  = const_dijkstra_test.processed(t);
+    d  = const_dijkstra_test.distMap();
+    p  = const_dijkstra_test.predMap();
+    pp = const_dijkstra_test.path(t);
+    l  = const_dijkstra_test.currentDist(t);
+  }
+  {
+    DType
+      ::SetPredMap<concepts::ReadWriteMap<Node,Arc> >
+      ::SetDistMap<concepts::ReadWriteMap<Node,VType> >
+      ::SetStandardProcessedMap
+      ::SetProcessedMap<concepts::WriteMap<Node,bool> >
+      ::SetOperationTraits<DijkstraDefaultOperationTraits<VType> >
+      ::SetHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> > >
+      ::SetStandardHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> > >
+      ::SetHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> >, 
+                concepts::ReadWriteMap<Node,int> >
+      ::Create dijkstra_test(G,length);
+
+    LengthMap length_map;
+    concepts::ReadWriteMap<Node,Arc> pred_map;
+    concepts::ReadWriteMap<Node,VType> dist_map;
+    concepts::WriteMap<Node,bool> processed_map;
+    concepts::ReadWriteMap<Node,int> heap_cross_ref;
+    BinHeap<VType, concepts::ReadWriteMap<Node,int> > heap(heap_cross_ref);
+    
+    dijkstra_test
+      .lengthMap(length_map)
+      .predMap(pred_map)
+      .distMap(dist_map)
+      .processedMap(processed_map)
+      .heap(heap, heap_cross_ref);
+
+    dijkstra_test.run(s);
+    dijkstra_test.run(s,t);
+
+    dijkstra_test.addSource(s);
+    dijkstra_test.addSource(s, 1);
+    n = dijkstra_test.processNextNode();
+    n = dijkstra_test.nextNode();
+    b = dijkstra_test.emptyQueue();
+    i = dijkstra_test.queueSize();
+    
+    dijkstra_test.start();
+    dijkstra_test.start(t);
+    dijkstra_test.start(nm);
 
     l  = dijkstra_test.dist(t);
@@ -80,27 +146,7 @@
     s  = dijkstra_test.predNode(t);
     b  = dijkstra_test.reached(t);
-    d  = dijkstra_test.distMap();
-    p  = dijkstra_test.predMap();
+    b  = dijkstra_test.processed(t);
     pp = dijkstra_test.path(t);
-  }
-  {
-    DType
-      ::SetPredMap<concepts::ReadWriteMap<Node,Arc> >
-      ::SetDistMap<concepts::ReadWriteMap<Node,VType> >
-      ::SetProcessedMap<concepts::WriteMap<Node,bool> >
-      ::SetStandardProcessedMap
-      ::SetOperationTraits<DijkstraDefaultOperationTraits<VType> >
-      ::SetHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> > >
-      ::SetStandardHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> > >
-      ::Create dijkstra_test(G,length);
-
-    dijkstra_test.run(s);
-    dijkstra_test.run(s,t);
-
-    l  = dijkstra_test.dist(t);
-    e  = dijkstra_test.predArc(t);
-    s  = dijkstra_test.predNode(t);
-    b  = dijkstra_test.reached(t);
-    pp = dijkstra_test.path(t);
+    l  = dijkstra_test.currentDist(t);
   }
 
Index: test/preflow_test.cc
===================================================================
--- test/preflow_test.cc	(revision 463)
+++ test/preflow_test.cc	(revision 632)
@@ -85,16 +85,20 @@
   FlowMap flow;
   CutMap cut;
-
-  Preflow<Digraph, CapMap>
-    ::SetFlowMap<FlowMap>
-    ::SetElevator<Elev>
-    ::SetStandardElevator<LinkedElev>
-    ::Create preflow_test(g,cap,n,n);
-
-  preflow_test.capacityMap(cap);
-  flow = preflow_test.flowMap();
-  preflow_test.flowMap(flow);
-  preflow_test.source(n);
-  preflow_test.target(n);
+  VType v;
+  bool b;
+
+  typedef Preflow<Digraph, CapMap>
+            ::SetFlowMap<FlowMap>
+            ::SetElevator<Elev>
+            ::SetStandardElevator<LinkedElev>
+            ::Create PreflowType;
+  PreflowType preflow_test(g, cap, n, n);
+  const PreflowType& const_preflow_test = preflow_test;
+
+  preflow_test
+    .capacityMap(cap)
+    .flowMap(flow)
+    .source(n)
+    .target(n);
 
   preflow_test.init();
@@ -105,9 +109,11 @@
   preflow_test.runMinCut();
 
-  preflow_test.flowValue();
-  preflow_test.minCut(n);
-  preflow_test.minCutMap(cut);
-  preflow_test.flow(e);
-
+  v = const_preflow_test.flowValue();
+  v = const_preflow_test.flow(e);
+  const FlowMap& fm = const_preflow_test.flowMap();
+  b = const_preflow_test.minCut(n);
+  const_preflow_test.minCutMap(cut);
+  
+  ignore_unused_variable_warning(fm);
 }
 
Index: tools/dimacs-solver.cc
===================================================================
--- tools/dimacs-solver.cc	(revision 631)
+++ tools/dimacs-solver.cc	(revision 616)
@@ -24,8 +24,9 @@
 ///
 /// See
-/// \code
-///   dimacs-solver --help
-/// \endcode
+/// \verbatim
+///  dimacs-solver --help
+/// \endverbatim
 /// for more info on usage.
+///
 
 #include <iostream>
Index: tools/dimacs-to-lgf.cc
===================================================================
--- tools/dimacs-to-lgf.cc	(revision 631)
+++ tools/dimacs-to-lgf.cc	(revision 608)
@@ -25,8 +25,9 @@
 ///
 /// See
-/// \code
-///   dimacs-to-lgf --help
-/// \endcode
-/// for more info on the usage.
+/// \verbatim
+///  dimacs-to-lgf --help
+/// \endverbatim
+/// for more info on usage.
+///
 
 #include <iostream>
Index: tools/lgf-gen.cc
===================================================================
--- tools/lgf-gen.cc	(revision 631)
+++ tools/lgf-gen.cc	(revision 617)
@@ -24,8 +24,10 @@
 ///
 /// See
-/// \code
-///   lgf-gen --help
-/// \endcode
+/// \verbatim
+///  lgf-gen --help
+/// \endverbatim
 /// for more info on the usage.
+///
+
 
 #include <algorithm>
