Changeset 559:c5fd2d996909 – LEMON

doc/groups.dox

-                      r455
+                      r559
 /**
 @defgroup datas Data Structures
 This group describes the several data structures implemented in LEMON.
+This group contains the several data structures implemented in LEMON.
 */
 …
 \brief Graph types between real graphs and graph adaptors.
 This group describes some graph types between real graphs and graph adaptors.
+This group contains some graph types between real graphs and graph adaptors.
 These classes wrap graphs to give new functionality as the adaptors do it.
 On the other hand they are not light-weight structures as the adaptors.
 …
 \brief Map structures implemented in LEMON.
 This group describes the map structures implemented in LEMON.
+This group contains the map structures implemented in LEMON.
 LEMON provides several special purpose maps and map adaptors that e.g. combine
 …
 \brief Special graph-related maps.
 This group describes maps that are specifically designed to assign
+This group contains maps that are specifically designed to assign
 values to the nodes and arcs/edges of graphs.
 …
 \brief Tools to create new maps from existing ones
 This group describes map adaptors that are used to create "implicit"
+This group contains map adaptors that are used to create "implicit"
 maps from other maps.
 …
 \brief Two dimensional data storages implemented in LEMON.
 This group describes two dimensional data storages implemented in LEMON.
+This group contains two dimensional data storages implemented in LEMON.
 */
 …
 \brief %Path structures implemented in LEMON.
 This group describes the path structures implemented in LEMON.
+This group contains the path structures implemented in LEMON.
 LEMON provides flexible data structures to work with paths.
 …
 \brief Auxiliary data structures implemented in LEMON.
 This group describes some data structures implemented in LEMON in
+This group contains some data structures implemented in LEMON in
 order to make it easier to implement combinatorial algorithms.
 */
 …
 /**
 @defgroup algs Algorithms
 \brief This group describes the several algorithms
+\brief This group contains the several algorithms
 implemented in LEMON.
 This group describes the several algorithms
+This group contains the several algorithms
 implemented in LEMON.
 */
 …
 \brief Common graph search algorithms.
 This group describes the common graph search algorithms, namely
+This group contains the common graph search algorithms, namely
 \e breadth-first \e search (BFS) and \e depth-first \e search (DFS).
 */
 …
 \brief Algorithms for finding shortest paths.
 This group describes the algorithms for finding shortest paths in digraphs.
+This group contains the algorithms for finding shortest paths in digraphs.
  - \ref Dijkstra algorithm for finding shortest paths from a source node
 …
 \brief Algorithms for finding maximum flows.
 This group describes the algorithms for finding maximum flows and
+This group contains the algorithms for finding maximum flows and
 feasible circulations.
 …
 \brief Algorithms for finding minimum cost flows and circulations.
 This group describes the algorithms for finding minimum cost flows and
+This group contains the algorithms for finding minimum cost flows and
 circulations.
 …
 \brief Algorithms for finding minimum cut in graphs.
 This group describes the algorithms for finding minimum cut in graphs.
+This group contains the algorithms for finding minimum cut in graphs.
 The \e minimum \e cut \e problem is to find a non-empty and non-complete
 …
 - \ref NagamochiIbaraki "Nagamochi-Ibaraki algorithm" for
   calculating minimum cut in undirected graphs.
 - \ref GomoryHuTree "Gomory-Hu tree computation" for calculating
+- \ref GomoryHu "Gomory-Hu tree computation" for calculating
   all-pairs minimum cut in undirected graphs.
 …
 \brief Algorithms for discovering the graph properties
 This group describes the algorithms for discovering the graph properties
+This group contains the algorithms for discovering the graph properties
 like connectivity, bipartiteness, euler property, simplicity etc.
 …
 \brief Algorithms for planarity checking, embedding and drawing
 This group describes the algorithms for planarity checking,
+This group contains the algorithms for planarity checking,
 embedding and drawing.
 …
 \brief Algorithms for finding a minimum cost spanning tree in a graph.
 This group describes the algorithms for finding a minimum cost spanning
+This group contains the algorithms for finding a minimum cost spanning
 tree in a graph.
 */
 …
 \brief Auxiliary algorithms implemented in LEMON.
 This group describes some algorithms implemented in LEMON
+This group contains some algorithms implemented in LEMON
 in order to make it easier to implement complex algorithms.
 */
 …
 \brief Approximation algorithms.
 This group describes the approximation and heuristic algorithms
+This group contains the approximation and heuristic algorithms
 implemented in LEMON.
 */
 …
 /**
 @defgroup gen_opt_group General Optimization Tools
 \brief This group describes some general optimization frameworks
+\brief This group contains some general optimization frameworks
 implemented in LEMON.
 This group describes some general optimization frameworks
+This group contains some general optimization frameworks
 implemented in LEMON.
 */
 …
 \brief Lp and Mip solver interfaces for LEMON.
 This group describes Lp and Mip solver interfaces for LEMON. The
+This group contains Lp and Mip solver interfaces for LEMON. The
 various LP solvers could be used in the same manner with this
 interface.
 …
 \brief Metaheuristics for LEMON library.
 This group describes some metaheuristic optimization tools.
+This group contains some metaheuristic optimization tools.
 */
 …
 \brief Simple basic graph utilities.
 This group describes some simple basic graph utilities.
+This group contains some simple basic graph utilities.
 */
 …
 \brief Tools for development, debugging and testing.
 This group describes several useful tools for development,
+This group contains several useful tools for development,
 debugging and testing.
 */
 …
 \brief Simple tools for measuring the performance of algorithms.
 This group describes simple tools for measuring the performance
+This group contains simple tools for measuring the performance
 of algorithms.
 */
 …
 \brief Exceptions defined in LEMON.
 This group describes the exceptions defined in LEMON.
+This group contains the exceptions defined in LEMON.
 */
 …
 \brief Graph Input-Output methods
 This group describes the tools for importing and exporting graphs
+This group contains the tools for importing and exporting graphs
 and graph related data. Now it supports the \ref lgf-format
 "LEMON Graph Format", the \c DIMACS format and the encapsulated
 …
 \brief Reading and writing LEMON Graph Format.
 This group describes methods for reading and writing
+This group contains methods for reading and writing
 \ref lgf-format "LEMON Graph Format".
 */
 …
 \brief General \c EPS drawer and graph exporter
 This group describes general \c EPS drawing methods and special
+This group contains general \c EPS drawing methods and special
 graph exporting tools.
 */
 …
 \brief Skeleton classes and concept checking classes
 This group describes the data/algorithm skeletons and concept checking
+This group contains the data/algorithm skeletons and concept checking
 classes implemented in LEMON.
 …
 \brief Skeleton and concept checking classes for graph structures
 This group describes the skeletons and concept checking classes of LEMON's
+This group contains the skeletons and concept checking classes of LEMON's
 graph structures and helper classes used to implement these.
 */
 …
 \brief Skeleton and concept checking classes for maps
 This group describes the skeletons and concept checking classes of maps.
+This group contains the skeletons and concept checking classes of maps.
 */

doc/mainpage.dox

-                      r440
+                      r559
 "Quick Tour to LEMON" which will guide you along.
+If you already feel like using our library, see the page that tells you
+\ref getstart "How to start using LEMON".
+If you
+want to see how LEMON works, see
+some \ref demoprograms "demo programs".
+If you already feel like using our library, see the
+<a class="el" href="http://lemon.cs.elte.hu/pub/tutorial/">LEMON Tutorial</a>.
 If you know what you are looking for then try to find it under the
+<a class="el" href="modules.html">Modules</a>
+section.
+<a class="el" href="modules.html">Modules</a> section.
 If you are a user of the old (0.x) series of LEMON, please check out the

lemon/adaptors.h

-                      r519
+                      r559
     /// This map adaptor class adapts two arc maps of the underlying
     /// digraph to get an arc map of the undirected graph.
+    /// Its value type is inherited from the first arc map type
+    /// (\c %ForwardMap).
+    template <typename ForwardMap, typename BackwardMap>
+    /// Its value type is inherited from the first arc map type (\c FW).
+    /// \tparam FW The type of the "foward" arc map.
+    /// \tparam BK The type of the "backward" arc map.
+    template <typename FW, typename BK>
     class CombinedArcMap {
     public:
 …
       typedef typename Parent::Arc Key;
       /// The value type of the map
       typedef typename ForwardMap::Value Value;
       typedef typename MapTraits<ForwardMap>::ReferenceMapTag ReferenceMapTag;
       typedef typename MapTraits<ForwardMap>::ReturnValue ReturnValue;
       typedef typename MapTraits<ForwardMap>::ConstReturnValue ConstReturnValue;
       typedef typename MapTraits<ForwardMap>::ReturnValue Reference;
       typedef typename MapTraits<ForwardMap>::ConstReturnValue ConstReference;
+      typedef typename FW::Value Value;
+      typedef typename MapTraits<FW>::ReferenceMapTag ReferenceMapTag;
+      typedef typename MapTraits<FW>::ReturnValue ReturnValue;
+      typedef typename MapTraits<FW>::ConstReturnValue ConstReturnValue;
+      typedef typename MapTraits<FW>::ReturnValue Reference;
+      typedef typename MapTraits<FW>::ConstReturnValue ConstReference;
       /// Constructor
       CombinedArcMap(ForwardMap& forward, BackwardMap& backward)
+      CombinedArcMap(FW& forward, BK& backward)
         : _forward(&forward), _backward(&backward) {}
 …
     protected:
       ForwardMap* _forward;
       BackwardMap* _backward;
+      FW* _forward;
+      BK* _backward;
     };
 …
     ///
     /// This function just returns a combined arc map.
+    template <typename ForwardMap, typename BackwardMap>
+    static CombinedArcMap<ForwardMap, BackwardMap>
+    combinedArcMap(ForwardMap& forward, BackwardMap& backward) {
+      return CombinedArcMap<ForwardMap, BackwardMap>(forward, backward);
+    }
+    template <typename ForwardMap, typename BackwardMap>
+    static CombinedArcMap<const ForwardMap, BackwardMap>
+    combinedArcMap(const ForwardMap& forward, BackwardMap& backward) {
+      return CombinedArcMap<const ForwardMap,
+        BackwardMap>(forward, backward);
+    }
+    template <typename ForwardMap, typename BackwardMap>
+    static CombinedArcMap<ForwardMap, const BackwardMap>
+    combinedArcMap(ForwardMap& forward, const BackwardMap& backward) {
+      return CombinedArcMap<ForwardMap,
+        const BackwardMap>(forward, backward);
+    }
+    template <typename ForwardMap, typename BackwardMap>
+    static CombinedArcMap<const ForwardMap, const BackwardMap>
+    combinedArcMap(const ForwardMap& forward, const BackwardMap& backward) {
+      return CombinedArcMap<const ForwardMap,
+        const BackwardMap>(forward, backward);
+    template <typename FW, typename BK>
+    static CombinedArcMap<FW, BK>
+    combinedArcMap(FW& forward, BK& backward) {
+      return CombinedArcMap<FW, BK>(forward, backward);
+    }
+    template <typename FW, typename BK>
+    static CombinedArcMap<const FW, BK>
+    combinedArcMap(const FW& forward, BK& backward) {
+      return CombinedArcMap<const FW, BK>(forward, backward);
+    }
+    template <typename FW, typename BK>
+    static CombinedArcMap<FW, const BK>
+    combinedArcMap(FW& forward, const BK& backward) {
+      return CombinedArcMap<FW, const BK>(forward, backward);
+    }
+    template <typename FW, typename BK>
+    static CombinedArcMap<const FW, const BK>
+    combinedArcMap(const FW& forward, const BK& backward) {
+      return CombinedArcMap<const FW, const BK>(forward, backward);
+    }
 …
     /// This map adaptor class adapts two node maps of the original digraph
     /// to get a node map of the split digraph.
+    /// Its value type is inherited from the first node map type
+    /// (\c InNodeMap).
+    template <typename InNodeMap, typename OutNodeMap>
+    /// Its value type is inherited from the first node map type (\c IN).
+    /// \tparam IN The type of the node map for the in-nodes.
+    /// \tparam OUT The type of the node map for the out-nodes.
+    template <typename IN, typename OUT>
     class CombinedNodeMap {
     public:
 …
       typedef Node Key;
       /// The value type of the map
       typedef typename InNodeMap::Value Value;
       typedef typename MapTraits<InNodeMap>::ReferenceMapTag ReferenceMapTag;
       typedef typename MapTraits<InNodeMap>::ReturnValue ReturnValue;
       typedef typename MapTraits<InNodeMap>::ConstReturnValue ConstReturnValue;
       typedef typename MapTraits<InNodeMap>::ReturnValue Reference;
       typedef typename MapTraits<InNodeMap>::ConstReturnValue ConstReference;
+      typedef typename IN::Value Value;
+      typedef typename MapTraits<IN>::ReferenceMapTag ReferenceMapTag;
+      typedef typename MapTraits<IN>::ReturnValue ReturnValue;
+      typedef typename MapTraits<IN>::ConstReturnValue ConstReturnValue;
+      typedef typename MapTraits<IN>::ReturnValue Reference;
+      typedef typename MapTraits<IN>::ConstReturnValue ConstReference;
       /// Constructor
       CombinedNodeMap(InNodeMap& in_map, OutNodeMap& out_map)
+      CombinedNodeMap(IN& in_map, OUT& out_map)
         : _in_map(in_map), _out_map(out_map) {}
 …
     private:
       InNodeMap& _in_map;
       OutNodeMap& _out_map;
+      IN& _in_map;
+      OUT& _out_map;
     };
 …
     ///
     /// This function just returns a combined node map.
+    template <typename InNodeMap, typename OutNodeMap>
+    static CombinedNodeMap<InNodeMap, OutNodeMap>
+    combinedNodeMap(InNodeMap& in_map, OutNodeMap& out_map) {
+      return CombinedNodeMap<InNodeMap, OutNodeMap>(in_map, out_map);
+    }
+    template <typename InNodeMap, typename OutNodeMap>
+    static CombinedNodeMap<const InNodeMap, OutNodeMap>
+    combinedNodeMap(const InNodeMap& in_map, OutNodeMap& out_map) {
+      return CombinedNodeMap<const InNodeMap, OutNodeMap>(in_map, out_map);
+    }
+    template <typename InNodeMap, typename OutNodeMap>
+    static CombinedNodeMap<InNodeMap, const OutNodeMap>
+    combinedNodeMap(InNodeMap& in_map, const OutNodeMap& out_map) {
+      return CombinedNodeMap<InNodeMap, const OutNodeMap>(in_map, out_map);
+    }
+    template <typename InNodeMap, typename OutNodeMap>
+    static CombinedNodeMap<const InNodeMap, const OutNodeMap>
+    combinedNodeMap(const InNodeMap& in_map, const OutNodeMap& out_map) {
+      return CombinedNodeMap<const InNodeMap,
+        const OutNodeMap>(in_map, out_map);
+    template <typename IN, typename OUT>
+    static CombinedNodeMap<IN, OUT>
+    combinedNodeMap(IN& in_map, OUT& out_map) {
+      return CombinedNodeMap<IN, OUT>(in_map, out_map);
+    }
+    template <typename IN, typename OUT>
+    static CombinedNodeMap<const IN, OUT>
+    combinedNodeMap(const IN& in_map, OUT& out_map) {
+      return CombinedNodeMap<const IN, OUT>(in_map, out_map);
+    }
+    template <typename IN, typename OUT>
+    static CombinedNodeMap<IN, const OUT>
+    combinedNodeMap(IN& in_map, const OUT& out_map) {
+      return CombinedNodeMap<IN, const OUT>(in_map, out_map);
+    }
+    template <typename IN, typename OUT>
+    static CombinedNodeMap<const IN, const OUT>
+    combinedNodeMap(const IN& in_map, const OUT& out_map) {
+      return CombinedNodeMap<const IN, const OUT>(in_map, out_map);
+    }
 …
     /// This map adaptor class adapts an arc map and a node map of the
     /// original digraph to get an arc map of the split digraph.
+    /// Its value type is inherited from the original arc map type
+    /// (\c ArcMap).
+    template <typename ArcMap, typename NodeMap>
+    /// Its value type is inherited from the original arc map type (\c AM).
+    /// \tparam AM The type of the arc map.
+    /// \tparam NM the type of the node map.
+    template <typename AM, typename NM>
     class CombinedArcMap {
     public:
 …
       typedef Arc Key;
       /// The value type of the map
       typedef typename ArcMap::Value Value;
       typedef typename MapTraits<ArcMap>::ReferenceMapTag ReferenceMapTag;
       typedef typename MapTraits<ArcMap>::ReturnValue ReturnValue;
       typedef typename MapTraits<ArcMap>::ConstReturnValue ConstReturnValue;
       typedef typename MapTraits<ArcMap>::ReturnValue Reference;
       typedef typename MapTraits<ArcMap>::ConstReturnValue ConstReference;
+      typedef typename AM::Value Value;
+      typedef typename MapTraits<AM>::ReferenceMapTag ReferenceMapTag;
+      typedef typename MapTraits<AM>::ReturnValue ReturnValue;
+      typedef typename MapTraits<AM>::ConstReturnValue ConstReturnValue;
+      typedef typename MapTraits<AM>::ReturnValue Reference;
+      typedef typename MapTraits<AM>::ConstReturnValue ConstReference;
       /// Constructor
       CombinedArcMap(ArcMap& arc_map, NodeMap& node_map)
+      CombinedArcMap(AM& arc_map, NM& node_map)
         : _arc_map(arc_map), _node_map(node_map) {}
 …
     private:
+      ArcMap& _arc_map;
+      NodeMap& _node_map;
+      AM& _arc_map;
+      NM& _node_map;
     };

lemon/bin_heap.h

-                      r440
+                      r559
   ///\brief A Binary Heap implementation.
   ///
+  ///This class implements the \e binary \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. \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.
+  ///This class implements the \e binary \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. \c Comp specifies the ordering of the priorities.
+  ///In a heap one can change the priority of an item, add or erase an
+  ///item, etc.
   ///
   ///\tparam _Prio Type of the priority of the items.
   ///\tparam _ItemIntMap A read and writable Item int map, used internally
+  ///\tparam PR Type of the priority of the items.
+  ///\tparam IM A read and writable item map with int values, used internally
   ///to handle the cross references.
   ///\tparam _Compare A class for the ordering of the priorities. The
   ///default is \c std::less<_Prio>.
+  ///\tparam Comp A functor class for the ordering of the priorities.
+  ///The default is \c std::less<PR>.
   ///
   ///\sa FibHeap
   ///\sa Dijkstra
+  template <typename _Prio, typename _ItemIntMap,
+            typename _Compare = std::less<_Prio> >
+  template <typename PR, typename IM, typename Comp = std::less<PR> >
   class BinHeap {
   public:
     ///\e
     typedef _ItemIntMap ItemIntMap;
     ///\e
     typedef _Prio Prio;
+    typedef IM ItemIntMap;
+    ///\e
+    typedef PR Prio;
     ///\e
     typedef typename ItemIntMap::Key Item;
 …
     typedef std::pair<Item,Prio> Pair;
     ///\e
     typedef _Compare Compare;
+    typedef Comp Compare;
     /// \brief Type to represent the items states.
 …
     /// heap's point of view, but may be useful to the user.
     ///
     /// The ItemIntMap \e should be initialized in such way that it maps
     /// PRE_HEAP (-1) to any element to be put in the heap...
+    /// The item-int map must be initialized in such way that it assigns
+    /// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap.
     enum State {
       IN_HEAP = 0,
       PRE_HEAP = -1,
       POST_HEAP = -2
+      IN_HEAP = 0,    ///< \e
+      PRE_HEAP = -1,  ///< \e
+      POST_HEAP = -2  ///< \e
     };
   private:
     std::vector<Pair> data;
     Compare comp;
     ItemIntMap &iim;
+    std::vector<Pair> _data;
+    Compare _comp;
+    ItemIntMap &_iim;
   public:
 …
     ///
     /// The constructor.
+    /// \param _iim should be given to the constructor, since it is used
+    /// \param map should be given to the constructor, since it is used
+    /// internally to handle the cross references. The value of the map
+    /// must be \c PRE_HEAP (<tt>-1</tt>) for every item.
+    explicit BinHeap(ItemIntMap &map) : _iim(map) {}
+    /// \brief The constructor.
+    ///
+    /// The constructor.
+    /// \param map should be given to the constructor, since it is used
     /// internally to handle the cross references. The value of the map
     /// should be PRE_HEAP (-1) for each element.
+    explicit BinHeap(ItemIntMap &_iim) : iim(_iim) {}
+    /// \brief The constructor.
+    ///
+    /// The constructor.
+    /// \param _iim should be given to the constructor, since it is used
+    /// internally to handle the cross references. The value of the map
+    /// should be PRE_HEAP (-1) for each element.
+    ///
+    /// \param _comp The comparator function object.
+    BinHeap(ItemIntMap &_iim, const Compare &_comp)
+      : iim(_iim), comp(_comp) {}
+    ///
+    /// \param comp The comparator function object.
+    BinHeap(ItemIntMap &map, const Compare &comp)
+      : _iim(map), _comp(comp) {}
 …
     ///
     /// \brief Returns the number of items stored in the heap.
     int size() const { return data.size(); }
+    int size() const { return _data.size(); }
     /// \brief Checks if the heap stores no items.
     ///
     /// Returns \c true if and only if the heap stores no items.
     bool empty() const { return data.empty(); }
+    bool empty() const { return _data.empty(); }
     /// \brief Make empty this heap.
 …
     /// each item to \c PRE_HEAP.
     void clear() {
       data.clear();
+      _data.clear();
+    }
 …
     static int second_child(int i) { return 2*i+2; }
     bool less(const Pair &p1, const Pair &p2) const {
       return comp(p1.second, p2.second);
+      return _comp(p1.second, p2.second);
+    }
     int bubble_up(int hole, Pair p) {
       int par = parent(hole);
       while( hole>0 && less(p,data[par]) ) {
         move(data[par],hole);
+      while( hole>0 && less(p,_data[par]) ) {
+        move(_data[par],hole);
         hole = par;
         par = parent(hole);
 …
       int child = second_child(hole);
       while(child < length) {
         if( less(data[child-1], data[child]) ) {
+        if( less(_data[child-1], _data[child]) ) {
           --child;
+        }
         if( !less(data[child], p) )
+        if( !less(_data[child], p) )
           goto ok;
         move(data[child], hole);
+        move(_data[child], hole);
         hole = child;
         child = second_child(hole);
+      }
       child--;
       if( child<length && less(data[child], p) ) {
         move(data[child], hole);
+      if( child<length && less(_data[child], p) ) {
+        move(_data[child], hole);
         hole=child;
+      }
 …
     void move(const Pair &p, int i) {
       data[i] = p;
       iim.set(p.first, i);
+      _data[i] = p;
+      _iim.set(p.first, i);
+    }
 …
     /// \param p The pair to insert.
     void push(const Pair &p) {
       int n = data.size();
       data.resize(n+1);
+      int n = _data.size();
+      _data.resize(n+1);
       bubble_up(n, p);
+    }
 …
     /// \pre The heap must be nonempty.
     Item top() const {
       return data[0].first;
+      return _data[0].first;
+    }
 …
     /// \pre The heap must be nonempty.
     Prio prio() const {
       return data[0].second;
+      return _data[0].second;
+    }
 …
     /// \pre The heap must be non-empty.
     void pop() {
       int n = data.size()-1;
       iim.set(data[0].first, POST_HEAP);
+      int n = _data.size()-1;
+      _iim.set(_data[0].first, POST_HEAP);
       if (n > 0) {
         bubble_down(0, data[n], n);
+      }
       data.pop_back();
+        bubble_down(0, _data[n], n);
+      }
+      _data.pop_back();
+    }
 …
     /// \pre The item should be in the heap.
     void erase(const Item &i) {
       int h = iim[i];
       int n = data.size()-1;
       iim.set(data[h].first, POST_HEAP);
+      int h = _iim[i];
+      int n = _data.size()-1;
+      _iim.set(_data[h].first, POST_HEAP);
       if( h < n ) {
         if ( bubble_up(h, data[n]) == h) {
           bubble_down(h, data[n], n);
+        if ( bubble_up(h, _data[n]) == h) {
+          bubble_down(h, _data[n], n);
+        }
+      }
       data.pop_back();
+      _data.pop_back();
+    }
 …
     ///
     /// This function returns the priority of item \c i.
+    /// \param i The item.
     /// \pre \c i must be in the heap.
-    /// \param i The item.
     Prio operator[](const Item &i) const {
       int idx = iim[i];
       return data[idx].second;
+      int idx = _iim[i];
+      return _data[idx].second;
+    }
 …
     /// \param p The priority.
     void set(const Item &i, const Prio &p) {
       int idx = iim[i];
+      int idx = _iim[i];
       if( idx < 0 ) {
         push(i,p);
+      }
       else if( comp(p, data[idx].second) ) {
+      else if( _comp(p, _data[idx].second) ) {
         bubble_up(idx, Pair(i,p));
+      }
       else {
         bubble_down(idx, Pair(i,p), data.size());
+        bubble_down(idx, Pair(i,p), _data.size());
+      }
+    }
 …
     ///
     /// This method decreases the priority of item \c i to \c p.
+    /// \param i The item.
+    /// \param p The priority.
     /// \pre \c i must be stored in the heap with priority at least \c
     /// p relative to \c Compare.
+    void decrease(const Item &i, const Prio &p) {
+      int idx = _iim[i];
+      bubble_up(idx, Pair(i,p));
+    }
+    /// \brief Increases the priority of \c i to \c p.
+    ///
+    /// This method sets the priority of item \c i to \c p.
     /// \param i The item.
     /// \param p The priority.
-    void decrease(const Item &i, const Prio &p) {
-      int idx = iim[i];
-      bubble_up(idx, Pair(i,p));
+    }
-    /// \brief Increases the priority of \c i to \c p.
-    ///
-    /// This method sets the priority of item \c i to \c p.
     /// \pre \c i must be stored in the heap with priority at most \c
     /// p relative to \c Compare.
-    /// \param i The item.
-    /// \param p The priority.
     void increase(const Item &i, const Prio &p) {
       int idx = iim[i];
       bubble_down(idx, Pair(i,p), data.size());
+      int idx = _iim[i];
+      bubble_down(idx, Pair(i,p), _data.size());
+    }
 …
     /// \param i The item.
     State state(const Item &i) const {
       int s = iim[i];
+      int s = _iim[i];
       if( s>=0 )
         s=0;
 …
           erase(i);
+        }
         iim[i] = st;
+        _iim[i] = st;
         break;
       case IN_HEAP:
 …
     /// with the same prioriority as prevoiusly the \c i item.
     void replace(const Item& i, const Item& j) {
       int idx = iim[i];
       iim.set(i, iim[j]);
       iim.set(j, idx);
       data[idx].first = j;
+      int idx = _iim[i];
+      _iim.set(i, _iim[j]);
+      _iim.set(j, idx);
+      _data[idx].first = j;
+    }

lemon/bits/edge_set_extender.h

-                      r519
+                      r559
 #include <lemon/bits/map_extender.h>
 ///\ingroup digraphbits
 ///\file
 ///\brief Extenders for the arc set types
+//\ingroup digraphbits
+//\file
+//\brief Extenders for the arc set types
 namespace lemon {
   /// \ingroup digraphbits
   ///
   /// \brief Extender for the ArcSets
+  // \ingroup digraphbits
+  //
+  // \brief Extender for the ArcSets
   template <typename Base>
   class ArcSetExtender : public Base {
 …
     // Alteration notifier extensions
     /// The arc observer registry.
+    // The arc observer registry.
     typedef AlterationNotifier<ArcSetExtender, Arc> ArcNotifier;
 …
     using Parent::notifier;
+    /// \brief Gives back the arc alteration notifier.
+    ///
+    /// Gives back the arc alteration notifier.
+    // Gives back the arc alteration notifier.
     ArcNotifier& notifier(Arc) const {
       return arc_notifier;
 …
     };
     /// \brief Base node of the iterator
     ///
     /// Returns the base node (ie. the source in this case) of the iterator
+    // \brief Base node of the iterator
+    //
+    // Returns the base node (ie. the source in this case) of the iterator
     Node baseNode(const OutArcIt &e) const {
       return Parent::source(static_cast<const Arc&>(e));
+    }
     /// \brief Running node of the iterator
     ///
     /// Returns the running node (ie. the target in this case) of the
     /// iterator
+    // \brief Running node of the iterator
+    //
+    // Returns the running node (ie. the target in this case) of the
+    // iterator
     Node runningNode(const OutArcIt &e) const {
       return Parent::target(static_cast<const Arc&>(e));
+    }
     /// \brief Base node of the iterator
     ///
     /// Returns the base node (ie. the target in this case) of the iterator
+    // \brief Base node of the iterator
+    //
+    // Returns the base node (ie. the target in this case) of the iterator
     Node baseNode(const InArcIt &e) const {
       return Parent::target(static_cast<const Arc&>(e));
+    }
     /// \brief Running node of the iterator
     ///
     /// Returns the running node (ie. the source in this case) of the
     /// iterator
+    // \brief Running node of the iterator
+    //
+    // Returns the running node (ie. the source in this case) of the
+    // iterator
     Node runningNode(const InArcIt &e) const {
       return Parent::source(static_cast<const Arc&>(e));
 …
   /// \ingroup digraphbits
   ///
   /// \brief Extender for the EdgeSets
+  // \ingroup digraphbits
+  //
+  // \brief Extender for the EdgeSets
   template <typename Base>
   class EdgeSetExtender : public Base {
 …
     };
     /// \brief Base node of the iterator
     ///
     /// Returns the base node (ie. the source in this case) of the iterator
+    // \brief Base node of the iterator
+    //
+    // Returns the base node (ie. the source in this case) of the iterator
     Node baseNode(const OutArcIt &e) const {
       return Parent::source(static_cast<const Arc&>(e));
+    }
     /// \brief Running node of the iterator
     ///
     /// Returns the running node (ie. the target in this case) of the
     /// iterator
+    // \brief Running node of the iterator
+    //
+    // Returns the running node (ie. the target in this case) of the
+    // iterator
     Node runningNode(const OutArcIt &e) const {
       return Parent::target(static_cast<const Arc&>(e));
+    }
     /// \brief Base node of the iterator
     ///
     /// Returns the base node (ie. the target in this case) of the iterator
+    // \brief Base node of the iterator
+    //
+    // Returns the base node (ie. the target in this case) of the iterator
     Node baseNode(const InArcIt &e) const {
       return Parent::target(static_cast<const Arc&>(e));
+    }
     /// \brief Running node of the iterator
     ///
     /// Returns the running node (ie. the source in this case) of the
     /// iterator
+    // \brief Running node of the iterator
+    //
+    // Returns the running node (ie. the source in this case) of the
+    // iterator
     Node runningNode(const InArcIt &e) const {
       return Parent::source(static_cast<const Arc&>(e));
+    }
     /// Base node of the iterator
     ///
     /// Returns the base node of the iterator
+    // Base node of the iterator
+    //
+    // Returns the base node of the iterator
     Node baseNode(const IncEdgeIt &e) const {
       return e.direction ? u(e) : v(e);
+    }
     /// Running node of the iterator
     ///
     /// Returns the running node of the iterator
+    // Running node of the iterator
+    //
+    // Returns the running node of the iterator
     Node runningNode(const IncEdgeIt &e) const {
       return e.direction ? v(e) : u(e);

lemon/circulation.h

-                      r503
+                      r559
     ///@{
     template <typename _FlowMap>
+    template <typename T>
     struct SetFlowMapTraits : public Traits {
       typedef _FlowMap FlowMap;
+      typedef T FlowMap;
       static FlowMap *createFlowMap(const Digraph&) {
         LEMON_ASSERT(false, "FlowMap is not initialized");
 …
     /// \ref named-templ-param "Named parameter" for setting FlowMap
     /// type.
     template <typename _FlowMap>
+    template <typename T>
     struct SetFlowMap
       : public Circulation<Digraph, LCapMap, UCapMap, DeltaMap,
                            SetFlowMapTraits<_FlowMap> > {
+                           SetFlowMapTraits<T> > {
       typedef Circulation<Digraph, LCapMap, UCapMap, DeltaMap,
                           SetFlowMapTraits<_FlowMap> > Create;
+                          SetFlowMapTraits<T> > Create;
     };
     template <typename _Elevator>
+    template <typename T>
     struct SetElevatorTraits : public Traits {
       typedef _Elevator Elevator;
+      typedef T Elevator;
       static Elevator *createElevator(const Digraph&, int) {
         LEMON_ASSERT(false, "Elevator is not initialized");
 …
     /// \ref run() or \ref init().
     /// \sa SetStandardElevator
     template <typename _Elevator>
+    template <typename T>
     struct SetElevator
       : public Circulation<Digraph, LCapMap, UCapMap, DeltaMap,
                            SetElevatorTraits<_Elevator> > {
+                           SetElevatorTraits<T> > {
       typedef Circulation<Digraph, LCapMap, UCapMap, DeltaMap,
                           SetElevatorTraits<_Elevator> > Create;
+                          SetElevatorTraits<T> > Create;
     };
     template <typename _Elevator>
+    template <typename T>
     struct SetStandardElevatorTraits : public Traits {
       typedef _Elevator Elevator;
+      typedef T Elevator;
       static Elevator *createElevator(const Digraph& digraph, int max_level) {
         return new Elevator(digraph, max_level);
 …
     /// before calling \ref run() or \ref init().
     /// \sa SetElevator
     template <typename _Elevator>
+    template <typename T>
     struct SetStandardElevator
       : public Circulation<Digraph, LCapMap, UCapMap, DeltaMap,
                        SetStandardElevatorTraits<_Elevator> > {
+                       SetStandardElevatorTraits<T> > {
       typedef Circulation<Digraph, LCapMap, UCapMap, DeltaMap,
                       SetStandardElevatorTraits<_Elevator> > Create;
+                      SetStandardElevatorTraits<T> > Create;
     };
 …
     ///
     /// \note This function calls \ref barrier() for each node,
     /// so it runs in \f$O(n)\f$ time.
+    /// so it runs in O(n) time.
     ///
     /// \pre Either \ref run() or \ref init() must be called before

lemon/concepts/graph.h

-                      r529
+                      r559
       /// \brief Opposite node on an arc
       ///
       /// \return the opposite of the given Node on the given Edge
+      /// \return The opposite of the given node on the given edge.
       Node oppositeNode(Node, Edge) const { return INVALID; }
       /// \brief First node of the edge.
       ///
       /// \return the first node of the given Edge.
+      /// \return The first node of the given edge.
       ///
       /// Naturally edges don't have direction and thus
       /// don't have source and target node. But we use these two methods
       /// to query the two nodes of the arc. The direction of the arc
       /// which arises this way is called the inherent direction of the
+      /// don't have source and target node. However we use \c u() and \c v()
+      /// methods to query the two nodes of the arc. The direction of the
+      /// arc which arises this way is called the inherent direction of the
       /// edge, and is used to define the "default" direction
       /// of the directed versions of the arcs.
+      /// \sa direction
+      /// \sa v()
+      /// \sa direction()
       Node u(Edge) const { return INVALID; }
       /// \brief Second node of the edge.
+      ///
+      /// \return The second node of the given edge.
+      ///
+      /// Naturally edges don't have direction and thus
+      /// don't have source and target node. However we use \c u() and \c v()
+      /// methods to query the two nodes of the arc. The direction of the
+      /// arc which arises this way is called the inherent direction of the
+      /// edge, and is used to define the "default" direction
+      /// of the directed versions of the arcs.
+      /// \sa u()
+      /// \sa direction()
       Node v(Edge) const { return INVALID; }

lemon/concepts/graph_components.h

-                      r534
+                      r559
 ///\brief The concept of graph components.
 #ifndef LEMON_CONCEPTS_GRAPH_COMPONENTS_H
 #define LEMON_CONCEPTS_GRAPH_COMPONENTS_H
 …
 #ifndef DOXYGEN
     template <char _selector = '0'>
+    template <char sel = '0'>
 #endif
     class GraphItem {
 …
     /// The most of the base digraphs should conform to this concept.
     /// The id's are unique and immutable.
     template <typename _Base = BaseDigraphComponent>
     class IDableDigraphComponent : public _Base {
     public:
       typedef _Base Base;
+    template <typename BAS = BaseDigraphComponent>
+    class IDableDigraphComponent : public BAS {
+    public:
+      typedef BAS Base;
       typedef typename Base::Node Node;
       typedef typename Base::Arc Arc;
 …
     /// most of the base undirected graphs should conform to this
     /// concept.  The id's are unique and immutable.
     template <typename _Base = BaseGraphComponent>
     class IDableGraphComponent : public IDableDigraphComponent<_Base> {
     public:
       typedef _Base Base;
+    template <typename BAS = BaseGraphComponent>
+    class IDableGraphComponent : public IDableDigraphComponent<BAS> {
+    public:
+      typedef BAS Base;
       typedef typename Base::Edge Edge;
       using IDableDigraphComponent<_Base>::id;
+      using IDableDigraphComponent<Base>::id;
       /// \brief Gives back an unique integer id for the Edge.
 …
     /// Skeleton class for graph NodeIt and ArcIt.
     ///
     template <typename _Graph, typename _Item>
     class GraphItemIt : public _Item {
+    template <typename GR, typename Item>
+    class GraphItemIt : public Item {
     public:
       /// \brief Default constructor.
 …
       /// Sets the iterator to the first item of \c the graph.
       ///
       explicit GraphItemIt(const _Graph&) {}
+      explicit GraphItemIt(const GR&) {}
       /// \brief Invalid constructor \& conversion.
       ///
 …
           ++(++it1);
           _Item bi = it1;
+          Item bi = it1;
           bi = it2;
+        }
         _Graph& g;
+        GR& g;
       };
     };
 …
     ///
     /// \note Because InArcIt and OutArcIt may not inherit from the same
     /// base class, the _selector is a additional template parameter. For
     /// InArcIt you should instantiate it with character 'i' and for
+    /// base class, the \c sel is a additional template parameter (selector).
+    /// For InArcIt you should instantiate it with character 'i' and for
     /// OutArcIt with 'o'.
     template <typename _Graph,
               typename _Item = typename _Graph::Arc,
               typename _Base = typename _Graph::Node,
               char _selector = '0'>
     class GraphIncIt : public _Item {
+    template <typename GR,
+              typename Item = typename GR::Arc,
+              typename Base = typename GR::Node,
+              char sel = '0'>
+    class GraphIncIt : public Item {
     public:
       /// \brief Default constructor.
 …
       /// Copy constructor.
       ///
       GraphIncIt(GraphIncIt const& gi) : _Item(gi) {}
+      GraphIncIt(GraphIncIt const& gi) : Item(gi) {}
       /// \brief Sets the iterator to the first arc incoming into or outgoing
       /// from the node.
 …
       /// from the node.
       ///
       explicit GraphIncIt(const _Graph&, const _Base&) {}
+      explicit GraphIncIt(const GR&, const Base&) {}
       /// \brief Invalid constructor \& conversion.
       ///
 …
       struct Constraints {
         void constraints() {
           checkConcept<GraphItem<_selector>, _GraphIncIt>();
+          checkConcept<GraphItem<sel>, _GraphIncIt>();
           _GraphIncIt it1(graph, node);
           _GraphIncIt it2;
 …
           ++it2 = it1;
           ++(++it1);
           _Item e = it1;
+          Item e = it1;
           e = it2;
+        }
         _Item arc;
         _Base node;
         _Graph graph;
+        Item arc;
+        Base node;
+        GR graph;
         _GraphIncIt it;
       };
 …
     /// iterator based iterable interface for the digraph structure.
     /// This concept is part of the Digraph concept.
     template <typename _Base = BaseDigraphComponent>
     class IterableDigraphComponent : public _Base {
     public:
       typedef _Base Base;
+    template <typename BAS = BaseDigraphComponent>
+    class IterableDigraphComponent : public BAS {
+    public:
+      typedef BAS Base;
       typedef typename Base::Node Node;
       typedef typename Base::Arc Arc;
 …
     /// based iterable interface for the undirected graph structure.
     /// This concept is part of the Graph concept.
     template <typename _Base = BaseGraphComponent>
     class IterableGraphComponent : public IterableDigraphComponent<_Base> {
     public:
       typedef _Base Base;
+    template <typename BAS = BaseGraphComponent>
+    class IterableGraphComponent : public IterableDigraphComponent<BAS> {
+    public:
+      typedef BAS Base;
       typedef typename Base::Node Node;
       typedef typename Base::Arc Arc;
 …
       /// @{
       using IterableDigraphComponent<_Base>::first;
       using IterableDigraphComponent<_Base>::next;
+      using IterableDigraphComponent<Base>::first;
+      using IterableDigraphComponent<Base>::next;
       /// \brief Gives back the first edge in the iterating
 …
       void nextInc(Edge&, bool&) const {}
       using IterableDigraphComponent<_Base>::baseNode;
       using IterableDigraphComponent<_Base>::runningNode;
+      using IterableDigraphComponent<Base>::baseNode;
+      using IterableDigraphComponent<Base>::runningNode;
       /// @}
 …
         const _Graph& graph;
       };
     };
 …
     /// alteration occured in the digraph all the observers will
     /// notified about it.
     template <typename _Base = BaseDigraphComponent>
     class AlterableDigraphComponent : public _Base {
     public:
       typedef _Base Base;
+    template <typename BAS = BaseDigraphComponent>
+    class AlterableDigraphComponent : public BAS {
+    public:
+      typedef BAS Base;
       typedef typename Base::Node Node;
       typedef typename Base::Arc Arc;
 …
     /// alteration occured in the graph all the observers will
     /// notified about it.
     template <typename _Base = BaseGraphComponent>
     class AlterableGraphComponent : public AlterableDigraphComponent<_Base> {
     public:
       typedef _Base Base;
+    template <typename BAS = BaseGraphComponent>
+    class AlterableGraphComponent : public AlterableDigraphComponent<BAS> {
+    public:
+      typedef BAS Base;
       typedef typename Base::Edge Edge;
 …
         const _Graph& graph;
+      };
+      };
     };
 …
     /// (NodeMap, ArcMap), that is maps that can be used to
     /// associate data to graph descriptors (nodes or arcs).
     template <typename _Graph, typename _Item, typename _Value>
     class GraphMap : public ReadWriteMap<_Item, _Value> {
     public:
       typedef ReadWriteMap<_Item, _Value> Parent;
+    template <typename GR, typename K, typename V>
+    class GraphMap : public ReadWriteMap<K, V> {
+    public:
+      typedef ReadWriteMap<K, V> Parent;
       /// The graph type of the map.
       typedef _Graph Graph;
+      typedef GR Graph;
       /// The key type of the map.
       typedef _Item Key;
+      typedef K Key;
       /// The value type of the map.
       typedef _Value Value;
+      typedef V Value;
       /// \brief Construct a new map.
 …
     /// map interface for the digraph structure.
     /// This concept is part of the Digraph concept.
     template <typename _Base = BaseDigraphComponent>
     class MappableDigraphComponent : public _Base  {
     public:
       typedef _Base Base;
+    template <typename BAS = BaseDigraphComponent>
+    class MappableDigraphComponent : public BAS  {
+    public:
+      typedef BAS Base;
       typedef typename Base::Node Node;
       typedef typename Base::Arc Arc;
 …
       /// ReadWrite map of the nodes.
       ///
       template <typename _Value>
       class NodeMap : public GraphMap<Digraph, Node, _Value> {
+      template <typename V>
+      class NodeMap : public GraphMap<Digraph, Node, V> {
       public:
         typedef GraphMap<MappableDigraphComponent, Node, _Value> Parent;
+        typedef GraphMap<MappableDigraphComponent, Node, V> Parent;
         /// \brief Construct a new map.
 …
         ///
         /// Construct a new map for the digraph and initalise the values.
         NodeMap(const MappableDigraphComponent& digraph, const _Value& value)
+        NodeMap(const MappableDigraphComponent& digraph, const V& value)
           : Parent(digraph, value) {}
 …
         template <typename CMap>
         NodeMap& operator=(const CMap&) {
           checkConcept<ReadMap<Node, _Value>, CMap>();
+          checkConcept<ReadMap<Node, V>, CMap>();
           return *this;
+        }
 …
       /// ReadWrite map of the arcs.
       ///
       template <typename _Value>
       class ArcMap : public GraphMap<Digraph, Arc, _Value> {
+      template <typename V>
+      class ArcMap : public GraphMap<Digraph, Arc, V> {
       public:
         typedef GraphMap<MappableDigraphComponent, Arc, _Value> Parent;
+        typedef GraphMap<MappableDigraphComponent, Arc, V> Parent;
         /// \brief Construct a new map.
 …
         ///
         /// Construct a new map for the digraph and initalise the values.
         ArcMap(const MappableDigraphComponent& digraph, const _Value& value)
+        ArcMap(const MappableDigraphComponent& digraph, const V& value)
           : Parent(digraph, value) {}
 …
         template <typename CMap>
         ArcMap& operator=(const CMap&) {
           checkConcept<ReadMap<Arc, _Value>, CMap>();
+          checkConcept<ReadMap<Arc, V>, CMap>();
           return *this;
+        }
 …
     /// map interface for the graph structure.
     /// This concept is part of the Graph concept.
     template <typename _Base = BaseGraphComponent>
     class MappableGraphComponent : public MappableDigraphComponent<_Base>  {
     public:
       typedef _Base Base;
+    template <typename BAS = BaseGraphComponent>
+    class MappableGraphComponent : public MappableDigraphComponent<BAS>  {
+    public:
+      typedef BAS Base;
       typedef typename Base::Edge Edge;
 …
       /// ReadWrite map of the edges.
       ///
       template <typename _Value>
       class EdgeMap : public GraphMap<Graph, Edge, _Value> {
+      template <typename V>
+      class EdgeMap : public GraphMap<Graph, Edge, V> {
       public:
         typedef GraphMap<MappableGraphComponent, Edge, _Value> Parent;
+        typedef GraphMap<MappableGraphComponent, Edge, V> Parent;
         /// \brief Construct a new map.
 …
         ///
         /// Construct a new map for the graph and initalise the values.
         EdgeMap(const MappableGraphComponent& graph, const _Value& value)
+        EdgeMap(const MappableGraphComponent& graph, const V& value)
           : Parent(graph, value) {}
 …
         template <typename CMap>
         EdgeMap& operator=(const CMap&) {
           checkConcept<ReadMap<Edge, _Value>, CMap>();
+          checkConcept<ReadMap<Edge, V>, CMap>();
           return *this;
+        }
 …
     /// difference between the base and this interface is that the
     /// digraph alterations should handled already on this level.
     template <typename _Base = BaseDigraphComponent>
     class ExtendableDigraphComponent : public _Base {
     public:
       typedef _Base Base;
       typedef typename _Base::Node Node;
       typedef typename _Base::Arc Arc;
+    template <typename BAS = BaseDigraphComponent>
+    class ExtendableDigraphComponent : public BAS {
+    public:
+      typedef BAS Base;
+      typedef typename Base::Node Node;
+      typedef typename Base::Arc Arc;
       /// \brief Adds a new node to the digraph.
 …
     /// that the graph alterations should handled already on this
     /// level.
     template <typename _Base = BaseGraphComponent>
     class ExtendableGraphComponent : public _Base {
     public:
       typedef _Base Base;
       typedef typename _Base::Node Node;
       typedef typename _Base::Edge Edge;
+    template <typename BAS = BaseGraphComponent>
+    class ExtendableGraphComponent : public BAS {
+    public:
+      typedef BAS Base;
+      typedef typename Base::Node Node;
+      typedef typename Base::Edge Edge;
       /// \brief Adds a new node to the graph.
 …
     /// the base and this interface is that the digraph alterations
     /// should handled already on this level.
     template <typename _Base = BaseDigraphComponent>
     class ErasableDigraphComponent : public _Base {
     public:
       typedef _Base Base;
+    template <typename BAS = BaseDigraphComponent>
+    class ErasableDigraphComponent : public BAS {
+    public:
+      typedef BAS Base;
       typedef typename Base::Node Node;
       typedef typename Base::Arc Arc;
 …
     /// main difference between the base and this interface is that
     /// the graph alterations should handled already on this level.
     template <typename _Base = BaseGraphComponent>
     class ErasableGraphComponent : public _Base {
     public:
       typedef _Base Base;
+    template <typename BAS = BaseGraphComponent>
+    class ErasableGraphComponent : public BAS {
+    public:
+      typedef BAS Base;
       typedef typename Base::Node Node;
       typedef typename Base::Edge Edge;
 …
     /// the base and this interface is that the digraph alterations
     /// should handled already on this level.
     template <typename _Base = BaseDigraphComponent>
     class ClearableDigraphComponent : public _Base {
     public:
       typedef _Base Base;
+    template <typename BAS = BaseDigraphComponent>
+    class ClearableDigraphComponent : public BAS {
+    public:
+      typedef BAS Base;
       /// \brief Erase all nodes and arcs from the digraph.
 …
     /// main difference between the base and this interface is that
     /// the graph alterations should handled already on this level.
     template <typename _Base = BaseGraphComponent>
     class ClearableGraphComponent : public ClearableDigraphComponent<_Base> {
     public:
       typedef _Base Base;
+    template <typename BAS = BaseGraphComponent>
+    class ClearableGraphComponent : public ClearableDigraphComponent<BAS> {
+    public:
+      typedef BAS Base;
       template <typename _Graph>

lemon/concepts/heap.h

-                      r529
+                      r559
     /// \brief The heap concept.
     ///
+    /// Concept class describing the main interface of heaps.
+    template <typename Priority, typename ItemIntMap>
+    /// Concept class describing the main interface of heaps. 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. In a heap one can change the priority of an
+    /// item, add or erase an item, etc.
+    ///
+    /// \tparam PR Type of the priority of the items.
+    /// \tparam IM A read and writable item map with int values, used
+    /// internally to handle the cross references.
+    /// \tparam Comp A functor class for the ordering of the priorities.
+    /// The default is \c std::less<PR>.
+#ifdef DOXYGEN
+    template <typename PR, typename IM, typename Comp = std::less<PR> >
+#else
+    template <typename PR, typename IM>
+#endif
     class Heap {
     public:
+      /// Type of the item-int map.
+      typedef IM ItemIntMap;
+      /// Type of the priorities.
+      typedef PR Prio;
       /// Type of the items stored in the heap.
       typedef typename ItemIntMap::Key Item;
-      /// Type of the priorities.
-      typedef Priority Prio;
       /// \brief Type to represent the states of the items.
 …
       /// the user.
       ///
       /// The \c ItemIntMap must be initialized in such a way, that it
       /// assigns \c PRE_HEAP (<tt>-1</tt>) to every item.
+      /// The item-int map must be initialized in such way that it assigns
+      /// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap.
       enum State {
         IN_HEAP = 0,
         PRE_HEAP = -1,
         POST_HEAP = -2
+        IN_HEAP = 0,    ///< The "in heap" state constant.
+        PRE_HEAP = -1,  ///< The "pre heap" state constant.
+        POST_HEAP = -2  ///< The "post heap" state constant.
       };
 …
       ///
       /// Returns the priority of the given item.
+      /// \param i The item.
       /// \pre \c i must be in the heap.
-      /// \param i The item.
       Prio operator[](const Item &i) const {}
 …
       ///
       /// Decreases the priority of an item to the given value.
+      /// \param i The item.
+      /// \param p The priority.
       /// \pre \c i must be stored in the heap with priority at least \c p.
+      void decrease(const Item &i, const Prio &p) {}
+      /// \brief Increases the priority of an item to the given value.
+      ///
+      /// Increases the priority of an item to the given value.
       /// \param i The item.
       /// \param p The priority.
-      void decrease(const Item &i, const Prio &p) {}
-      /// \brief Increases the priority of an item to the given value.
-      ///
-      /// Increases the priority of an item to the given value.
       /// \pre \c i must be stored in the heap with priority at most \c p.
-      /// \param i The item.
-      /// \param p The priority.
       void increase(const Item &i, const Prio &p) {}

lemon/concepts/path.h

-                      r529
+                      r559
     /// A skeleton structure for representing directed paths in a
     /// digraph.
     /// \tparam _Digraph The digraph type in which the path is.
+    /// \tparam GR The digraph type in which the path is.
     ///
     /// In a sense, the path can be treated as a list of arcs. The
 …
     /// paths cannot store the source.
     ///
     template <typename _Digraph>
+    template <typename GR>
     class Path {
     public:
       /// Type of the underlying digraph.
       typedef _Digraph Digraph;
+      typedef GR Digraph;
       /// Arc type of the underlying digraph.
       typedef typename Digraph::Arc Arc;
 …
     /// assigned to a real path and the dumpers can be implemented as
     /// an adaptor class to the predecessor map.
     /// \tparam _Digraph  The digraph type in which the path is.
+    ///
+    /// \tparam GR The digraph type in which the path is.
     ///
     /// The paths can be constructed from any path type by a
     /// template constructor or a template assignment operator.
+    ///
+    template <typename _Digraph>
+    template <typename GR>
     class PathDumper {
     public:
       /// Type of the underlying digraph.
       typedef _Digraph Digraph;
+      typedef GR Digraph;
       /// Arc type of the underlying digraph.
       typedef typename Digraph::Arc Arc;

lemon/connectivity.h

-                      r440
+                      r559
   /// Check whether the given undirected graph is connected.
   /// \param graph The undirected graph.
   /// \return %True when there is path between any two nodes in the graph.
+  /// \return \c true when there is path between any two nodes in the graph.
   /// \note By definition, the empty graph is connected.
   template <typename Graph>
 …
   /// graph is strongly connected when any two nodes of the graph are
   /// connected with directed paths in both direction.
   /// \return %False when the graph is not strongly connected.
+  /// \return \c false when the graph is not strongly connected.
   /// \see connected
   ///
 …
   ///
   /// \param graph The graph.
   /// \return %True when the graph bi-node-connected.
+  /// \return \c true when the graph bi-node-connected.
   template <typename Graph>
   bool biNodeConnected(const Graph& graph) {
 …
   /// of the map will be set exactly once, the values will be set descending
   /// order.
   /// \return %False when the graph is not DAG.
+  /// \return \c false when the graph is not DAG.
   ///
   /// \see topologicalSort
 …
   /// Check that the given directed graph is a DAG. The DAG is
   /// an Directed Acyclic Digraph.
   /// \return %False when the graph is not DAG.
+  /// \return \c false when the graph is not DAG.
   /// \see acyclic
   template <typename Digraph>
 …
   /// Check that the given undirected graph acyclic.
   /// \param graph The undirected graph.
   /// \return %True when there is no circle in the graph.
+  /// \return \c true when there is no circle in the graph.
   /// \see dag
   template <typename Graph>
 …
   /// Check that the given undirected graph is tree.
   /// \param graph The undirected graph.
   /// \return %True when the graph is acyclic and connected.
+  /// \return \c true when the graph is acyclic and connected.
   template <typename Graph>
   bool tree(const Graph& graph) {
 …
   /// or not. The \ref Bfs algorithm is used to calculate the result.
   /// \param graph The undirected graph.
   /// \return %True if \c graph is bipartite, %false otherwise.
+  /// \return \c true if \c graph is bipartite, \c false otherwise.
   /// \sa bipartitePartitions
   template<typename Graph>
 …
   /// \retval partMap A writable bool map of nodes. It will be set as the
   /// two partitions of the graph.
   /// \return %True if \c graph is bipartite, %false otherwise.
+  /// \return \c true if \c graph is bipartite, \c false otherwise.
   template<typename Graph, typename NodeMap>
   inline bool bipartitePartitions(const Graph &graph, NodeMap &partMap){

lemon/core.h

-                      r535
+                      r559
   ///\sa findArc()
   ///\sa ArcLookUp, AllArcLookUp, DynArcLookUp
   template <typename _Graph>
   class ConArcIt : public _Graph::Arc {
+  template <typename GR>
+  class ConArcIt : public GR::Arc {
   public:
     typedef _Graph Graph;
+    typedef GR Graph;
     typedef typename Graph::Arc Parent;
 …
   ///
   ///\sa findEdge()
   template <typename _Graph>
   class ConEdgeIt : public _Graph::Edge {
+  template <typename GR>
+  class ConEdgeIt : public GR::Edge {
   public:
     typedef _Graph Graph;
+    typedef GR Graph;
     typedef typename Graph::Edge Parent;
 …
   ///queries.
   ///
   ///\tparam G The type of the underlying digraph.
+  ///\tparam GR The type of the underlying digraph.
   ///
   ///\sa ArcLookUp
   ///\sa AllArcLookUp
   template<class G>
+  template <typename GR>
   class DynArcLookUp
     : protected ItemSetTraits<G, typename G::Arc>::ItemNotifier::ObserverBase
+    : protected ItemSetTraits<GR, typename GR::Arc>::ItemNotifier::ObserverBase
+  {
   public:
     typedef typename ItemSetTraits<G, typename G::Arc>
+    typedef typename ItemSetTraits<GR, typename GR::Arc>
     ::ItemNotifier::ObserverBase Parent;
     TEMPLATE_DIGRAPH_TYPEDEFS(G);
     typedef G Digraph;
+    TEMPLATE_DIGRAPH_TYPEDEFS(GR);
+    typedef GR Digraph;
   protected:
     class AutoNodeMap : public ItemSetTraits<G, Node>::template Map<Arc>::Type {
+    class AutoNodeMap : public ItemSetTraits<GR, Node>::template Map<Arc>::Type {
     public:
       typedef typename ItemSetTraits<G, Node>::template Map<Arc>::Type Parent;
       AutoNodeMap(const G& digraph) : Parent(digraph, INVALID) {}
+      typedef typename ItemSetTraits<GR, Node>::template Map<Arc>::Type Parent;
+      AutoNodeMap(const GR& digraph) : Parent(digraph, INVALID) {}
       virtual void add(const Node& node) {
 …
   ///(<em>O</em>(<em>m</em> log<em>m</em>)) to the number of arcs).
   ///
   ///\tparam G The type of the underlying digraph.
+  ///\tparam GR The type of the underlying digraph.
   ///
   ///\sa DynArcLookUp
   ///\sa AllArcLookUp
   template<class G>
+  template<class GR>
   class ArcLookUp
+  {
   public:
     TEMPLATE_DIGRAPH_TYPEDEFS(G);
     typedef G Digraph;
+    TEMPLATE_DIGRAPH_TYPEDEFS(GR);
+    typedef GR Digraph;
   protected:
 …
   ///(<em>O</em>(<em>m</em> log<em>m</em>)) to the number of arcs).
   ///
   ///\tparam G The type of the underlying digraph.
+  ///\tparam GR The type of the underlying digraph.
   ///
   ///\sa DynArcLookUp
   ///\sa ArcLookUp
   template<class G>
   class AllArcLookUp : public ArcLookUp<G>
+  template<class GR>
+  class AllArcLookUp : public ArcLookUp<GR>
+  {
     using ArcLookUp<G>::_g;
     using ArcLookUp<G>::_right;
     using ArcLookUp<G>::_left;
     using ArcLookUp<G>::_head;
     TEMPLATE_DIGRAPH_TYPEDEFS(G);
     typedef G Digraph;
+    using ArcLookUp<GR>::_g;
+    using ArcLookUp<GR>::_right;
+    using ArcLookUp<GR>::_left;
+    using ArcLookUp<GR>::_head;
+    TEMPLATE_DIGRAPH_TYPEDEFS(GR);
+    typedef GR Digraph;
     typename Digraph::template ArcMap<Arc> _next;
 …
     ///It builds up the search database, which remains valid until the digraph
     ///changes.
     AllArcLookUp(const Digraph &g) : ArcLookUp<G>(g), _next(g) {refreshNext();}
+    AllArcLookUp(const Digraph &g) : ArcLookUp<GR>(g), _next(g) {refreshNext();}
     ///Refresh the data structure at a node.
 …
     void refresh(Node n)
+    {
       ArcLookUp<G>::refresh(n);
+      ArcLookUp<GR>::refresh(n);
       refreshNext(_head[n]);
+    }
 …
     Arc operator()(Node s, Node t, Arc prev=INVALID) const {}
 #else
     using ArcLookUp<G>::operator() ;
+    using ArcLookUp<GR>::operator() ;
     Arc operator()(Node s, Node t, Arc prev) const
+    {

lemon/dijkstra.h

-                      r503
+                      r559
   /// This operation traits class defines all computational operations and
   /// constants which are used in the Dijkstra algorithm.
   template <typename Value>
+  template <typename V>
   struct DijkstraDefaultOperationTraits {
+    /// \e
+    typedef V Value;
     /// \brief Gives back the zero value of the type.
     static Value zero() {
 …
   ///Default traits class of Dijkstra class.
   ///\tparam GR The type of the digraph.
   ///\tparam LM The type of the length map.
   template<class GR, class LM>
+  ///\tparam LEN The type of the length map.
+  template<typename GR, typename LEN>
   struct DijkstraDefaultTraits
+  {
 …
     ///The type of the map that stores the arc lengths.
     ///It must meet the \ref concepts::ReadMap "ReadMap" concept.
     typedef LM LengthMap;
+    typedef LEN LengthMap;
     ///The type of the length of the arcs.
     typedef typename LM::Value Value;
+    typedef typename LEN::Value Value;
     /// Operation traits for %Dijkstra algorithm.
 …
     ///\sa BinHeap
     ///\sa Dijkstra
     typedef BinHeap<typename LM::Value, HeapCrossRef, std::less<Value> > Heap;
+    typedef BinHeap<typename LEN::Value, HeapCrossRef, std::less<Value> > Heap;
     ///Instantiates a \c Heap.
 …
     ///The type of the map that stores the distances of the nodes.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename LM::Value> DistMap;
+    typedef typename Digraph::template NodeMap<typename LEN::Value> DistMap;
     ///Instantiates a \c DistMap.
 …
   ///\tparam GR The type of the digraph the algorithm runs on.
   ///The default type is \ref ListDigraph.
   ///\tparam LM A \ref concepts::ReadMap "readable" arc map that specifies
+  ///\tparam LEN A \ref concepts::ReadMap "readable" arc map that specifies
   ///the lengths of the arcs.
   ///It is read once for each arc, so the map may involve in
 …
   ///concepts::Digraph::ArcMap "GR::ArcMap<int>".
 #ifdef DOXYGEN
   template <typename GR, typename LM, typename TR>
+  template <typename GR, typename LEN, typename TR>
 #else
   template <typename GR=ListDigraph,
             typename LM=typename GR::template ArcMap<int>,
             typename TR=DijkstraDefaultTraits<GR,LM> >
+            typename LEN=typename GR::template ArcMap<int>,
+            typename TR=DijkstraDefaultTraits<GR,LEN> >
 #endif
   class Dijkstra {
 …
   ///Default traits class of dijkstra() function.
   ///\tparam GR The type of the digraph.
   ///\tparam LM The type of the length map.
   template<class GR, class LM>
+  ///\tparam LEN The type of the length map.
+  template<class GR, class LEN>
   struct DijkstraWizardDefaultTraits
+  {
 …
     ///The type of the map that stores the arc lengths.
     ///It must meet the \ref concepts::ReadMap "ReadMap" concept.
     typedef LM LengthMap;
+    typedef LEN LengthMap;
     ///The type of the length of the arcs.
     typedef typename LM::Value Value;
+    typedef typename LEN::Value Value;
     /// Operation traits for Dijkstra algorithm.
 …
     ///The type of the map that stores the distances of the nodes.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename LM::Value> DistMap;
+    typedef typename Digraph::template NodeMap<typename LEN::Value> DistMap;
     ///Instantiates a DistMap.
 …
   /// The \ref DijkstraWizardBase is a class to be the default traits of the
   /// \ref DijkstraWizard class.
   template<class GR,class LM>
   class DijkstraWizardBase : public DijkstraWizardDefaultTraits<GR,LM>
+  template<typename GR, typename LEN>
+  class DijkstraWizardBase : public DijkstraWizardDefaultTraits<GR,LEN>
+  {
     typedef DijkstraWizardDefaultTraits<GR,LM> Base;
+    typedef DijkstraWizardDefaultTraits<GR,LEN> Base;
   protected:
     //The type of the nodes in the digraph.
 …
     /// \param g The digraph the algorithm runs on.
     /// \param l The length map.
     DijkstraWizardBase(const GR &g,const LM &l) :
+    DijkstraWizardBase(const GR &g,const LEN &l) :
       _g(reinterpret_cast<void*>(const_cast<GR*>(&g))),
       _length(reinterpret_cast<void*>(const_cast<LM*>(&l))),
+      _length(reinterpret_cast<void*>(const_cast<LEN*>(&l))),
       _processed(0), _pred(0), _dist(0), _path(0), _di(0) {}
 …
   ///\sa DijkstraWizard
   ///\sa Dijkstra
   template<class GR, class LM>
   DijkstraWizard<DijkstraWizardBase<GR,LM> >
   dijkstra(const GR &digraph, const LM &length)
+  template<typename GR, typename LEN>
+  DijkstraWizard<DijkstraWizardBase<GR,LEN> >
+  dijkstra(const GR &digraph, const LEN &length)
+  {
     return DijkstraWizard<DijkstraWizardBase<GR,LM> >(digraph,length);
+    return DijkstraWizard<DijkstraWizardBase<GR,LEN> >(digraph,length);
+  }

lemon/edge_set.h

-                      r488
+                      r559
   /// concept.
   ///
   /// This class is fully conform to the \ref concepts::Digraph
+  /// This class fully conforms to the \ref concepts::Digraph
   /// "Digraph" concept.
   template <typename GR>
 …
     /// Add a new arc to the digraph with source node \c s
     /// and target node \c t.
     /// \return the new arc.
+    /// \return The new arc.
     Arc addArc(const Node& s, const Node& t) {
       return Parent::addArc(s, t);
 …
   /// concept.
   ///
   /// This class is fully conform to the \ref concepts::Graph "Graph"
+  /// This class fully conforms to the \ref concepts::Graph "Graph"
   /// concept.
   template <typename GR>
 …
     /// Add a new edge to the graph with node \c u
     /// and node \c v endpoints.
     /// \return the new edge.
+    /// \return The new edge.
     Edge addEdge(const Node& u, const Node& v) {
       return Parent::addEdge(u, v);
 …
   /// validity can be checked with the \c valid() member function.
   ///
   /// This class is fully conform to the \ref concepts::Digraph
+  /// This class fully conforms to the \ref concepts::Digraph
   /// "Digraph" concept.
   template <typename GR>
 …
     /// Add a new arc to the digraph with source node \c s
     /// and target node \c t.
     /// \return the new arc.
+    /// \return The new arc.
     Arc addArc(const Node& s, const Node& t) {
       return Parent::addArc(s, t);
 …
   /// be checked with the \c valid() member function.
   ///
   /// This class is fully conform to the \ref concepts::Graph
+  /// This class fully conforms to the \ref concepts::Graph
   /// "Graph" concept.
   template <typename GR>
 …
     /// Add a new edge to the graph with node \c u
     /// and node \c v endpoints.
     /// \return the new edge.
+    /// \return The new edge.
     Edge addEdge(const Node& u, const Node& v) {
       return Parent::addEdge(u, v);

lemon/elevator.h

-                      r519
+                      r559
   ///\sa LinkedElevator
   ///
   ///\param Graph Type of the underlying graph.
   ///\param Item Type of the items the data is assigned to (Graph::Node,
   ///Graph::Arc, Graph::Edge).
   template<class Graph, class Item>
+  ///\param GR Type of the underlying graph.
+  ///\param Item Type of the items the data is assigned to (\c GR::Node,
+  ///\c GR::Arc or \c GR::Edge).
+  template<class GR, class Item>
   class Elevator
+  {
 …
     typedef Item *Vit;
     typedef typename ItemSetTraits<Graph,Item>::template Map<Vit>::Type VitMap;
     typedef typename ItemSetTraits<Graph,Item>::template Map<int>::Type IntMap;
     const Graph &_g;
+    typedef typename ItemSetTraits<GR,Item>::template Map<Vit>::Type VitMap;
+    typedef typename ItemSetTraits<GR,Item>::template Map<int>::Type IntMap;
+    const GR &_g;
     int _max_level;
     int _item_num;
 …
     ///\param max_level The maximum allowed level.
     ///Set the range of the possible labels to <tt>[0..max_level]</tt>.
     Elevator(const Graph &graph,int max_level) :
+    Elevator(const GR &graph,int max_level) :
       _g(graph),
       _max_level(max_level),
 …
     ///Set the range of the possible labels to <tt>[0..max_level]</tt>,
     ///where \c max_level is equal to the number of labeled items in the graph.
     Elevator(const Graph &graph) :
+    Elevator(const GR &graph) :
       _g(graph),
       _max_level(countItems<Graph, Item>(graph)),
+      _max_level(countItems<GR, Item>(graph)),
       _item_num(_max_level),
       _where(graph),
 …
       _last_active[0]=&_items[0]-1;
       Vit n=&_items[0];
       for(typename ItemSetTraits<Graph,Item>::ItemIt i(_g);i!=INVALID;++i)
+      for(typename ItemSetTraits<GR,Item>::ItemIt i(_g);i!=INVALID;++i)
+        {
           *n=i;
 …
   ///\sa Elevator
   ///
   ///\param Graph Type of the underlying graph.
   ///\param Item Type of the items the data is assigned to (Graph::Node,
   ///Graph::Arc, Graph::Edge).
   template <class Graph, class Item>
+  ///\param GR Type of the underlying graph.
+  ///\param Item Type of the items the data is assigned to (\c GR::Node,
+  ///\c GR::Arc or \c GR::Edge).
+  template <class GR, class Item>
   class LinkedElevator {
   public:
 …
   private:
     typedef typename ItemSetTraits<Graph,Item>::
+    typedef typename ItemSetTraits<GR,Item>::
     template Map<Item>::Type ItemMap;
     typedef typename ItemSetTraits<Graph,Item>::
+    typedef typename ItemSetTraits<GR,Item>::
     template Map<int>::Type IntMap;
     typedef typename ItemSetTraits<Graph,Item>::
+    typedef typename ItemSetTraits<GR,Item>::
     template Map<bool>::Type BoolMap;
     const Graph &_graph;
+    const GR &_graph;
     int _max_level;
     int _item_num;
 …
     ///\param max_level The maximum allowed level.
     ///Set the range of the possible labels to <tt>[0..max_level]</tt>.
     LinkedElevator(const Graph& graph, int max_level)
+    LinkedElevator(const GR& graph, int max_level)
       : _graph(graph), _max_level(max_level), _item_num(_max_level),
         _first(_max_level + 1), _last(_max_level + 1),
 …
     ///Set the range of the possible labels to <tt>[0..max_level]</tt>,
     ///where \c max_level is equal to the number of labeled items in the graph.
     LinkedElevator(const Graph& graph)
       : _graph(graph), _max_level(countItems<Graph, Item>(graph)),
+    LinkedElevator(const GR& graph)
+      : _graph(graph), _max_level(countItems<GR, Item>(graph)),
         _item_num(_max_level),
         _first(_max_level + 1), _last(_max_level + 1),
 …
+      }
       _init_level = 0;
       for(typename ItemSetTraits<Graph,Item>::ItemIt i(_graph);
+      for(typename ItemSetTraits<GR,Item>::ItemIt i(_graph);
           i != INVALID; ++i) {
         _level.set(i, _max_level);

lemon/euler.h

-                      r522
+                      r559
   ///If \c g is not Euler then the resulted tour will not be full or closed.
   ///\sa EulerIt
   template<class Digraph>
+  template<typename GR>
   class DiEulerIt
+  {
     typedef typename Digraph::Node Node;
     typedef typename Digraph::NodeIt NodeIt;
     typedef typename Digraph::Arc Arc;
     typedef typename Digraph::ArcIt ArcIt;
     typedef typename Digraph::OutArcIt OutArcIt;
     typedef typename Digraph::InArcIt InArcIt;
     const Digraph &g;
     typename Digraph::template NodeMap<OutArcIt> nedge;
+    typedef typename GR::Node Node;
+    typedef typename GR::NodeIt NodeIt;
+    typedef typename GR::Arc Arc;
+    typedef typename GR::ArcIt ArcIt;
+    typedef typename GR::OutArcIt OutArcIt;
+    typedef typename GR::InArcIt InArcIt;
+    const GR &g;
+    typename GR::template NodeMap<OutArcIt> nedge;
     std::list<Arc> euler;
 …
     ///Constructor
     ///\param _g A digraph.
+    ///\param gr A digraph.
     ///\param start The starting point of the tour. If it is not given
     ///       the tour will start from the first node.
     DiEulerIt(const Digraph &_g,typename Digraph::Node start=INVALID)
       : g(_g), nedge(g)
+    DiEulerIt(const GR &gr, typename GR::Node start = INVALID)
+      : g(gr), nedge(g)
+    {
       if(start==INVALID) start=NodeIt(g);
 …
   ///If \c g is not Euler then the resulted tour will not be full or closed.
   ///\sa EulerIt
   template<class Digraph>
+  template<typename GR>
   class EulerIt
+  {
     typedef typename Digraph::Node Node;
     typedef typename Digraph::NodeIt NodeIt;
     typedef typename Digraph::Arc Arc;
     typedef typename Digraph::Edge Edge;
     typedef typename Digraph::ArcIt ArcIt;
     typedef typename Digraph::OutArcIt OutArcIt;
     typedef typename Digraph::InArcIt InArcIt;
     const Digraph &g;
     typename Digraph::template NodeMap<OutArcIt> nedge;
     typename Digraph::template EdgeMap<bool> visited;
+    typedef typename GR::Node Node;
+    typedef typename GR::NodeIt NodeIt;
+    typedef typename GR::Arc Arc;
+    typedef typename GR::Edge Edge;
+    typedef typename GR::ArcIt ArcIt;
+    typedef typename GR::OutArcIt OutArcIt;
+    typedef typename GR::InArcIt InArcIt;
+    const GR &g;
+    typename GR::template NodeMap<OutArcIt> nedge;
+    typename GR::template EdgeMap<bool> visited;
     std::list<Arc> euler;
 …
     ///Constructor
     ///\param _g An graph.
+    ///\param gr An graph.
     ///\param start The starting point of the tour. If it is not given
     ///       the tour will start from the first node.
     EulerIt(const Digraph &_g,typename Digraph::Node start=INVALID)
       : g(_g), nedge(g), visited(g,false)
+    EulerIt(const GR &gr, typename GR::Node start = INVALID)
+      : g(gr), nedge(g), visited(g, false)
+    {
       if(start==INVALID) start=NodeIt(g);
 …
   ///for each node. <em>Therefore, there are digraphs which are not Eulerian,
   ///but still have an Euler tour</em>.
   template<class Digraph>
+  template<typename GR>
 #ifdef DOXYGEN
   bool
 #else
   typename enable_if<UndirectedTagIndicator<Digraph>,bool>::type
   eulerian(const Digraph &g)
+  {
     for(typename Digraph::NodeIt n(g);n!=INVALID;++n)
+  typename enable_if<UndirectedTagIndicator<GR>,bool>::type
+  eulerian(const GR &g)
+  {
+    for(typename GR::NodeIt n(g);n!=INVALID;++n)
       if(countIncEdges(g,n)%2) return false;
     return connected(g);
+  }
   template<class Digraph>
   typename disable_if<UndirectedTagIndicator<Digraph>,bool>::type
+  template<class GR>
+  typename disable_if<UndirectedTagIndicator<GR>,bool>::type
 #endif
   eulerian(const Digraph &g)
+  {
     for(typename Digraph::NodeIt n(g);n!=INVALID;++n)
+  eulerian(const GR &g)
+  {
+    for(typename GR::NodeIt n(g);n!=INVALID;++n)
       if(countInArcs(g,n)!=countOutArcs(g,n)) return false;
     return connected(Undirector<const Digraph>(g));
+    return connected(Undirector<const GR>(g));
+  }

lemon/graph_to_eps.h

-                      r492
+                      r559
 ///Default traits class of \ref GraphToEps.
 ///
 ///\c G is the type of the underlying graph.
 template<class G>
+///\param GR is the type of the underlying graph.
+template<class GR>
 struct DefaultGraphToEpsTraits
+{
   typedef G Graph;
+  typedef GR Graph;
   typedef typename Graph::Node Node;
   typedef typename Graph::NodeIt NodeIt;
 …
   ///Constructor
+  ///\param _g  Reference to the graph to be printed.
+  ///\param _os Reference to the output stream.
+  ///\param _os Reference to the output stream.
+  ///\param gr  Reference to the graph to be printed.
+  ///\param ost Reference to the output stream.
   ///By default it is <tt>std::cout</tt>.
   ///\param _pros If it is \c true, then the \c ostream referenced by \c _os
+  ///\param pros If it is \c true, then the \c ostream referenced by \c os
   ///will be explicitly deallocated by the destructor.
   DefaultGraphToEpsTraits(const G &_g,std::ostream& _os=std::cout,
                           bool _pros=false) :
     g(_g), os(_os),
+  DefaultGraphToEpsTraits(const GR &gr, std::ostream& ost = std::cout,
+                          bool pros = false) :
+    g(gr), os(ost),
     _coords(dim2::Point<double>(1,1)), _nodeSizes(1), _nodeShapes(0),
     _nodeColors(WHITE), _arcColors(BLACK),
 …
     _showNodeText(false), _nodeTexts(false), _nodeTextSize(1),
     _showNodePsText(false), _nodePsTexts(false), _nodePsTextsPreamble(0),
     _undirected(lemon::UndirectedTagIndicator<G>::value),
     _pleaseRemoveOsStream(_pros), _scaleToA4(false),
+    _undirected(lemon::UndirectedTagIndicator<GR>::value),
+    _pleaseRemoveOsStream(pros), _scaleToA4(false),
     _nodeTextColorType(SAME_COL), _nodeTextColors(BLACK),
     _autoNodeScale(false),
 …
 ///to the end of the parameter list.
 ///\sa GraphToEps
 ///\sa graphToEps(G &g, const char *file_name)
 template<class G>
 GraphToEps<DefaultGraphToEpsTraits<G> >
 graphToEps(G &g, std::ostream& os=std::cout)
+///\sa graphToEps(GR &g, const char *file_name)
+template<class GR>
+GraphToEps<DefaultGraphToEpsTraits<GR> >
+graphToEps(GR &g, std::ostream& os=std::cout)
+{
   return
     GraphToEps<DefaultGraphToEpsTraits<G> >(DefaultGraphToEpsTraits<G>(g,os));
+    GraphToEps<DefaultGraphToEpsTraits<GR> >(DefaultGraphToEpsTraits<GR>(g,os));
+}
 …
 ///\ingroup eps_io
 ///This function does the same as
 ///\ref graphToEps(G &g,std::ostream& os)
+///\ref graphToEps(GR &g,std::ostream& os)
 ///but it writes its output into the file \c file_name
 ///instead of a stream.
 ///\sa graphToEps(G &g, std::ostream& os)
 template<class G>
 GraphToEps<DefaultGraphToEpsTraits<G> >
 graphToEps(G &g,const char *file_name)
+///\sa graphToEps(GR &g, std::ostream& os)
+template<class GR>
+GraphToEps<DefaultGraphToEpsTraits<GR> >
+graphToEps(GR &g,const char *file_name)
+{
   std::ostream* os = new std::ofstream(file_name);
 …
     throw IoError("Cannot write file", file_name);
+  }
   return GraphToEps<DefaultGraphToEpsTraits<G> >
     (DefaultGraphToEpsTraits<G>(g,*os,true));
+  return GraphToEps<DefaultGraphToEpsTraits<GR> >
+    (DefaultGraphToEpsTraits<GR>(g,*os,true));
+}
 …
 ///\ingroup eps_io
 ///This function does the same as
 ///\ref graphToEps(G &g,std::ostream& os)
+///\ref graphToEps(GR &g,std::ostream& os)
 ///but it writes its output into the file \c file_name
 ///instead of a stream.
 ///\sa graphToEps(G &g, std::ostream& os)
 template<class G>
 GraphToEps<DefaultGraphToEpsTraits<G> >
 graphToEps(G &g,const std::string& file_name)
+///\sa graphToEps(GR &g, std::ostream& os)
+template<class GR>
+GraphToEps<DefaultGraphToEpsTraits<GR> >
+graphToEps(GR &g,const std::string& file_name)
+{
   std::ostream* os = new std::ofstream(file_name.c_str());
 …
     throw IoError("Cannot write file", file_name);
+  }
   return GraphToEps<DefaultGraphToEpsTraits<G> >
     (DefaultGraphToEpsTraits<G>(g,*os,true));
+  return GraphToEps<DefaultGraphToEpsTraits<GR> >
+    (DefaultGraphToEpsTraits<GR>(g,*os,true));
+}

lemon/grid_graph.h

r440	r559
497	497	///\endcode
498	498	///
499		/// This graph type ~~is fully conform~~ to the \ref concepts::Graph
	499	/// This graph type fully conforms to the \ref concepts::Graph
500	500	/// "Graph" concept, and it also has an important extra feature
501	501	/// that its maps are real \ref concepts::ReferenceMap

lemon/hao_orlin.h

-                      r440
+                      r559
   /// algorithm or you can use the algorithm of Nagamochi and Ibaraki
   /// which solves the undirected problem in
   /// \f$ O(nm + n^2 \log(n)) \f$ time: it is implemented in the
+  /// \f$ O(nm + n^2 \log n) \f$ time: it is implemented in the
   /// NagamochiIbaraki algorithm class.
   ///
   /// \param _Digraph is the graph type of the algorithm.
   /// \param _CapacityMap is an edge map of capacities which should
   /// be any numreric type. The default type is _Digraph::ArcMap<int>.
   /// \param _Tolerance is the handler of the inexact computation. The
   /// default type for this is Tolerance<CapacityMap::Value>.
+  /// \param GR The digraph class the algorithm runs on.
+  /// \param CAP An arc map of capacities which can be any numreric type.
+  /// The default type is \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
+  /// \param TOL Tolerance class for handling inexact computations. The
+  /// default tolerance type is \ref Tolerance "Tolerance<CAP::Value>".
 #ifdef DOXYGEN
   template <typename _Digraph, typename _CapacityMap, typename _Tolerance>
+  template <typename GR, typename CAP, typename TOL>
 #else
   template <typename _Digraph,
             typename _CapacityMap = typename _Digraph::template ArcMap<int>,
             typename _Tolerance = Tolerance<typename _CapacityMap::Value> >
+  template <typename GR,
+            typename CAP = typename GR::template ArcMap<int>,
+            typename TOL = Tolerance<typename CAP::Value> >
 #endif
   class HaoOrlin {
   private:
     typedef _Digraph Digraph;
     typedef _CapacityMap CapacityMap;
     typedef _Tolerance Tolerance;
+    typedef GR Digraph;
+    typedef CAP CapacityMap;
+    typedef TOL Tolerance;
     typedef typename CapacityMap::Value Value;
 …
     /// \name Execution control
     /// The simplest way to execute the algorithm is to use
     /// one of the member functions called \c run(...).
+    /// one of the member functions called \ref run().
     /// \n
     /// If you need more control on the execution,

lemon/hypercube_graph.h

r440	r559
292	292	/// (assuming that the size of \c int is 32 bit).
293	293	///
294		/// This graph type ~~is fully conform~~ to the \ref concepts::Graph
	294	/// This graph type fully conforms to the \ref concepts::Graph
295	295	/// "Graph" concept, and it also has an important extra feature
296	296	/// that its maps are real \ref concepts::ReferenceMap

lemon/lgf_reader.h

-                      r517
+                      r559
   /// a single pass, because the arcs are not constructed when the node
   /// maps are read.
   template <typename _Digraph>
+  template <typename GR>
   class DigraphReader {
   public:
+    typedef _Digraph Digraph;
+    typedef GR Digraph;
+  private:
     TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
-  private:
     std::istream* _is;
 …
   /// arc map.  Similarly, an attribute can be read into an arc, if
   /// it's value is an edge label prefixed with \c '+' or \c '-'.
   template <typename _Graph>
+  template <typename GR>
   class GraphReader {
   public:
+    typedef _Graph Graph;
+    typedef GR Graph;
+  private:
     TEMPLATE_GRAPH_TYPEDEFS(Graph);
-  private:
     std::istream* _is;
 …
   private:
     template <typename GR>
     friend GraphReader<GR> graphReader(GR& graph, std::istream& is);
     template <typename GR>
     friend GraphReader<GR> graphReader(GR& graph, const std::string& fn);
     template <typename GR>
     friend GraphReader<GR> graphReader(GR& graph, const char *fn);
+    template <typename Graph>
+    friend GraphReader<Graph> graphReader(Graph& graph, std::istream& is);
+    template <typename Graph>
+    friend GraphReader<Graph> graphReader(Graph& graph, const std::string& fn);
+    template <typename Graph>
+    friend GraphReader<Graph> graphReader(Graph& graph, const char *fn);
     GraphReader(GraphReader& other)

lemon/lgf_writer.h

-                      r517
+                      r559
   /// the \c ostream() function, hence the second pass can append its
   /// output to the output of the first pass.
   template <typename _Digraph>
+  template <typename GR>
   class DigraphWriter {
   public:
     typedef _Digraph Digraph;
+    typedef GR Digraph;
     TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
 …
   /// section as a \c '+' or a \c '-' prefix (depends on the direction
   /// of the arc) and the label of corresponding edge.
   template <typename _Graph>
+  template <typename GR>
   class GraphWriter {
   public:
     typedef _Graph Graph;
+    typedef GR Graph;
     TEMPLATE_GRAPH_TYPEDEFS(Graph);
 …
   private:
     template <typename GR>
     friend GraphWriter<GR> graphWriter(const GR& graph,
                                        std::ostream& os);
     template <typename GR>
     friend GraphWriter<GR> graphWriter(const GR& graph,
                                        const std::string& fn);
     template <typename GR>
     friend GraphWriter<GR> graphWriter(const GR& graph,
                                        const char *fn);
+    template <typename Graph>
+    friend GraphWriter<Graph> graphWriter(const Graph& graph,
+                                          std::ostream& os);
+    template <typename Graph>
+    friend GraphWriter<Graph> graphWriter(const Graph& graph,
+                                          const std::string& fn);
+    template <typename Graph>
+    friend GraphWriter<Graph> graphWriter(const Graph& graph,
+                                          const char *fn);
     GraphWriter(GraphWriter& other)

lemon/list_graph.h

-                      r440
+                      r559
     ///Add a new node to the digraph.
     ///\return the new node.
+    ///\return The new node.
     Node addNode() { return Parent::addNode(); }
 …
     ///Add a new arc to the digraph with source node \c s
     ///and target node \c t.
     ///\return the new arc.
+    ///\return The new arc.
     Arc addArc(const Node& s, const Node& t) {
       return Parent::addArc(s, t);
 …
     ///
     /// Add a new node to the graph.
     /// \return the new node.
+    /// \return The new node.
     Node addNode() { return Parent::addNode(); }
 …
     /// Add a new edge to the graph with source node \c s
     /// and target node \c t.
     /// \return the new edge.
+    /// \return The new edge.
     Edge addEdge(const Node& s, const Node& t) {
       return Parent::addEdge(s, t);

lemon/maps.h

-                      r440
+                      r559
   class NullMap : public MapBase<K, V> {
   public:
+    typedef MapBase<K, V> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
+    ///\e
+    typedef K Key;
+    ///\e
+    typedef V Value;
     /// Gives back a default constructed element.
 …
     V _value;
   public:
+    typedef MapBase<K, V> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
+    ///\e
+    typedef K Key;
+    ///\e
+    typedef V Value;
     /// Default constructor
 …
   class ConstMap<K, Const<V, v> > : public MapBase<K, V> {
   public:
+    typedef MapBase<K, V> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
+    ///\e
+    typedef K Key;
+    ///\e
+    typedef V Value;
     /// Constructor.
 …
   class IdentityMap : public MapBase<T, T> {
   public:
+    typedef MapBase<T, T> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
+    ///\e
+    typedef T Key;
+    ///\e
+    typedef T Value;
     /// Gives back the given value without any modification.
 …
   public:
-    typedef MapBase<int, V> Parent;
     /// Key type
     typedef typename Parent::Key Key;
+    typedef int Key;
     /// Value type
     typedef typename Parent::Value Value;
+    typedef V Value;
     /// Reference type
     typedef typename Vector::reference Reference;
 …
   /// The simplest way of using this map is through the sparseMap()
   /// function.
   template <typename K, typename V, typename Compare = std::less<K> >
+  template <typename K, typename V, typename Comp = std::less<K> >
   class SparseMap : public MapBase<K, V> {
     template <typename K1, typename V1, typename C1>
 …
   public:
-    typedef MapBase<K, V> Parent;
     /// Key type
     typedef typename Parent::Key Key;
+    typedef K Key;
     /// Value type
     typedef typename Parent::Value Value;
+    typedef V Value;
     /// Reference type
     typedef Value& Reference;
 …
   private:
     typedef std::map<K, V, Compare> Map;
+    typedef std::map<K, V, Comp> Map;
     Map _map;
     Value _value;
 …
     const M2 &_m2;
   public:
+    typedef MapBase<typename M2::Key, typename M1::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
+    ///\e
+    typedef typename M2::Key Key;
+    ///\e
+    typedef typename M1::Value Value;
     /// Constructor
     ComposeMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
     /// \e
+    ///\e
     typename MapTraits<M1>::ConstReturnValue
     operator[](const Key &k) const { return _m1[_m2[k]]; }
 …
     F _f;
   public:
+    typedef MapBase<typename M1::Key, V> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
+    ///\e
+    typedef typename M1::Key Key;
+    ///\e
+    typedef V Value;
     /// Constructor
     CombineMap(const M1 &m1, const M2 &m2, const F &f = F())
       : _m1(m1), _m2(m2), _f(f) {}
     /// \e
+    ///\e
     Value operator[](const Key &k) const { return _f(_m1[k],_m2[k]); }
   };
 …
     F _f;
   public:
+    typedef MapBase<K, V> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
+    ///\e
+    typedef K Key;
+    ///\e
+    typedef V Value;
     /// Constructor
     FunctorToMap(const F &f = F()) : _f(f) {}
     /// \e
+    ///\e
     Value operator[](const Key &k) const { return _f(k); }
   };
 …
     const M &_m;
   public:
+    typedef MapBase<typename M::Key, typename M::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
+    typedef typename Parent::Key argument_type;
+    typedef typename Parent::Value result_type;
+    ///\e
+    typedef typename M::Key Key;
+    ///\e
+    typedef typename M::Value Value;
+    typedef typename M::Key argument_type;
+    typedef typename M::Value result_type;
     /// Constructor
     MapToFunctor(const M &m) : _m(m) {}
     /// \e
+    ///\e
     Value operator()(const Key &k) const { return _m[k]; }
     /// \e
+    ///\e
     Value operator[](const Key &k) const { return _m[k]; }
   };
 …
     const M &_m;
   public:
+    typedef MapBase<typename M::Key, V> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
+    ///\e
+    typedef typename M::Key Key;
+    ///\e
+    typedef V Value;
     /// Constructor
 …
     ConvertMap(const M &m) : _m(m) {}
     /// \e
+    ///\e
     Value operator[](const Key &k) const { return _m[k]; }
   };
 …
     M2 &_m2;
   public:
+    typedef MapBase<typename M1::Key, typename M1::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
+    ///\e
+    typedef typename M1::Key Key;
+    ///\e
+    typedef typename M1::Value Value;
     /// Constructor
 …
     const M2 &_m2;
   public:
+    typedef MapBase<typename M1::Key, typename M1::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
+    ///\e
+    typedef typename M1::Key Key;
+    ///\e
+    typedef typename M1::Value Value;
     /// Constructor
     AddMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
     /// \e
+    ///\e
     Value operator[](const Key &k) const { return _m1[k]+_m2[k]; }
   };
 …
     const M2 &_m2;
   public:
+    typedef MapBase<typename M1::Key, typename M1::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
+    ///\e
+    typedef typename M1::Key Key;
+    ///\e
+    typedef typename M1::Value Value;
     /// Constructor
     SubMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
     /// \e
+    ///\e
     Value operator[](const Key &k) const { return _m1[k]-_m2[k]; }
   };
 …
     const M2 &_m2;
   public:
+    typedef MapBase<typename M1::Key, typename M1::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
+    ///\e
+    typedef typename M1::Key Key;
+    ///\e
+    typedef typename M1::Value Value;
     /// Constructor
     MulMap(const M1 &m1,const M2 &m2) : _m1(m1), _m2(m2) {}
     /// \e
+    ///\e
     Value operator[](const Key &k) const { return _m1[k]*_m2[k]; }
   };
 …
     const M2 &_m2;
   public:
+    typedef MapBase<typename M1::Key, typename M1::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
+    ///\e
+    typedef typename M1::Key Key;
+    ///\e
+    typedef typename M1::Value Value;
     /// Constructor
     DivMap(const M1 &m1,const M2 &m2) : _m1(m1), _m2(m2) {}
     /// \e
+    ///\e
     Value operator[](const Key &k) const { return _m1[k]/_m2[k]; }
   };
 …
     C _v;
   public:
+    typedef MapBase<typename M::Key, typename M::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
+    ///\e
+    typedef typename M::Key Key;
+    ///\e
+    typedef typename M::Value Value;
     /// Constructor
 …
     /// \param v The constant value.
     ShiftMap(const M &m, const C &v) : _m(m), _v(v) {}
     /// \e
+    ///\e
     Value operator[](const Key &k) const { return _m[k]+_v; }
   };
 …
     C _v;
   public:
+    typedef MapBase<typename M::Key, typename M::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
+    ///\e
+    typedef typename M::Key Key;
+    ///\e
+    typedef typename M::Value Value;
     /// Constructor
 …
     /// \param v The constant value.
     ShiftWriteMap(M &m, const C &v) : _m(m), _v(v) {}
     /// \e
+    ///\e
     Value operator[](const Key &k) const { return _m[k]+_v; }
     /// \e
+    ///\e
     void set(const Key &k, const Value &v) { _m.set(k, v-_v); }
   };
 …
     C _v;
   public:
+    typedef MapBase<typename M::Key, typename M::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
+    ///\e
+    typedef typename M::Key Key;
+    ///\e
+    typedef typename M::Value Value;
     /// Constructor
 …
     /// \param v The constant value.
     ScaleMap(const M &m, const C &v) : _m(m), _v(v) {}
     /// \e
+    ///\e
     Value operator[](const Key &k) const { return _v*_m[k]; }
   };
 …
     C _v;
   public:
+    typedef MapBase<typename M::Key, typename M::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
+    ///\e
+    typedef typename M::Key Key;
+    ///\e
+    typedef typename M::Value Value;
     /// Constructor
 …
     /// \param v The constant value.
     ScaleWriteMap(M &m, const C &v) : _m(m), _v(v) {}
     /// \e
+    ///\e
     Value operator[](const Key &k) const { return _v*_m[k]; }
     /// \e
+    ///\e
     void set(const Key &k, const Value &v) { _m.set(k, v/_v); }
   };
 …
     const M& _m;
   public:
+    typedef MapBase<typename M::Key, typename M::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
+    ///\e
+    typedef typename M::Key Key;
+    ///\e
+    typedef typename M::Value Value;
     /// Constructor
     NegMap(const M &m) : _m(m) {}
     /// \e
+    ///\e
     Value operator[](const Key &k) const { return -_m[k]; }
   };
 …
     M &_m;
   public:
+    typedef MapBase<typename M::Key, typename M::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
+    ///\e
+    typedef typename M::Key Key;
+    ///\e
+    typedef typename M::Value Value;
     /// Constructor
     NegWriteMap(M &m) : _m(m) {}
     /// \e
+    ///\e
     Value operator[](const Key &k) const { return -_m[k]; }
     /// \e
+    ///\e
     void set(const Key &k, const Value &v) { _m.set(k, -v); }
   };
 …
     const M &_m;
   public:
+    typedef MapBase<typename M::Key, typename M::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
+    ///\e
+    typedef typename M::Key Key;
+    ///\e
+    typedef typename M::Value Value;
     /// Constructor
     AbsMap(const M &m) : _m(m) {}
     /// \e
+    ///\e
     Value operator[](const Key &k) const {
       Value tmp = _m[k];
 …
   class TrueMap : public MapBase<K, bool> {
   public:
+    typedef MapBase<K, bool> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
+    ///\e
+    typedef K Key;
+    ///\e
+    typedef bool Value;
     /// Gives back \c true.
 …
   class FalseMap : public MapBase<K, bool> {
   public:
+    typedef MapBase<K, bool> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
+    ///\e
+    typedef K Key;
+    ///\e
+    typedef bool Value;
     /// Gives back \c false.
 …
     const M2 &_m2;
   public:
+    typedef MapBase<typename M1::Key, bool> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
+    ///\e
+    typedef typename M1::Key Key;
+    ///\e
+    typedef bool Value;
     /// Constructor
     AndMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
     /// \e
+    ///\e
     Value operator[](const Key &k) const { return _m1[k]&&_m2[k]; }
   };
 …
     const M2 &_m2;
   public:
+    typedef MapBase<typename M1::Key, bool> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
+    ///\e
+    typedef typename M1::Key Key;
+    ///\e
+    typedef bool Value;
     /// Constructor
     OrMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
     /// \e
+    ///\e
     Value operator[](const Key &k) const { return _m1[k]||_m2[k]; }
   };
 …
     const M &_m;
   public:
+    typedef MapBase<typename M::Key, bool> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
+    ///\e
+    typedef typename M::Key Key;
+    ///\e
+    typedef bool Value;
     /// Constructor
     NotMap(const M &m) : _m(m) {}
     /// \e
+    ///\e
     Value operator[](const Key &k) const { return !_m[k]; }
   };
 …
     M &_m;
   public:
+    typedef MapBase<typename M::Key, bool> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
+    ///\e
+    typedef typename M::Key Key;
+    ///\e
+    typedef bool Value;
     /// Constructor
     NotWriteMap(M &m) : _m(m) {}
     /// \e
+    ///\e
     Value operator[](const Key &k) const { return !_m[k]; }
     /// \e
+    ///\e
     void set(const Key &k, bool v) { _m.set(k, !v); }
   };
 …
     const M2 &_m2;
   public:
+    typedef MapBase<typename M1::Key, bool> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
+    ///\e
+    typedef typename M1::Key Key;
+    ///\e
+    typedef bool Value;
     /// Constructor
     EqualMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
     /// \e
+    ///\e
     Value operator[](const Key &k) const { return _m1[k]==_m2[k]; }
   };
 …
     const M2 &_m2;
   public:
+    typedef MapBase<typename M1::Key, bool> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
+    ///\e
+    typedef typename M1::Key Key;
+    ///\e
+    typedef bool Value;
     /// Constructor
     LessMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
     /// \e
+    ///\e
     Value operator[](const Key &k) const { return _m1[k]<_m2[k]; }
   };
 …
   /// function.
   ///
   /// \tparam It The type of the iterator.
   /// \tparam Ke The key type of the map. The default value set
+  /// \tparam IT The type of the iterator.
+  /// \tparam KEY The key type of the map. The default value set
   /// according to the iterator type should work in most cases.
   ///
 …
   /// for the elements or the iterator should be an inserter iterator.
 #ifdef DOXYGEN
   template <typename It, typename Ke>
+  template <typename IT, typename KEY>
 #else
   template <typename It,
             typename Ke=typename _maps_bits::IteratorTraits<It>::Value>
+  template <typename IT,
+            typename KEY = typename _maps_bits::IteratorTraits<IT>::Value>
 #endif
+  class LoggerBoolMap {
+  public:
+    typedef It Iterator;
+    typedef Ke Key;
+  class LoggerBoolMap : public MapBase<KEY, bool> {
+  public:
+    ///\e
+    typedef KEY Key;
+    ///\e
     typedef bool Value;
+    ///\e
+    typedef IT Iterator;
     /// Constructor
 …
   /// @{
+  /// Provides an immutable and unique id for each item in the graph.
+  /// The IdMap class provides a unique and immutable id for each item of the
+  /// same type (e.g. node) in the graph. This id is <ul><li>\b unique:
+  /// different items (nodes) get different ids <li>\b immutable: the id of an
+  /// item (node) does not change (even if you delete other nodes).  </ul>
+  /// Through this map you get access (i.e. can read) the inner id values of
+  /// the items stored in the graph. This map can be inverted with its member
+  /// \brief Provides an immutable and unique id for each item in a graph.
+  ///
+  /// IdMap provides a unique and immutable id for each item of the
+  /// same type (\c Node, \c Arc or \c Edge) in a graph. This id is
+  ///  - \b unique: different items get different ids,
+  ///  - \b immutable: the id of an item does not change (even if you
+  ///    delete other nodes).
+  ///
+  /// Using this map you get access (i.e. can read) the inner id values of
+  /// the items stored in the graph, which is returned by the \c id()
+  /// function of the graph. This map can be inverted with its member
   /// class \c InverseMap or with the \c operator() member.
   ///
+  template <typename _Graph, typename _Item>
+  class IdMap {
+  public:
+    typedef _Graph Graph;
+  /// \tparam GR The graph type.
+  /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or
+  /// \c GR::Edge).
+  ///
+  /// \see DescriptorMap
+  template <typename GR, typename K>
+  class IdMap : public MapBase<K, int> {
+  public:
+    /// The graph type of IdMap.
+    typedef GR Graph;
+    /// The key type of IdMap (\c Node, \c Arc or \c Edge).
+    typedef K Item;
+    /// The key type of IdMap (\c Node, \c Arc or \c Edge).
+    typedef K Key;
+    /// The value type of IdMap.
     typedef int Value;
-    typedef _Item Item;
-    typedef _Item Key;
     /// \brief Constructor.
 …
     int operator[](const Item& item) const { return _graph->id(item);}
     /// \brief Gives back the item by its id.
     ///
     /// Gives back the item by its id.
+    /// \brief Gives back the \e item by its id.
+    ///
+    /// Gives back the \e item by its id.
     Item operator()(int id) { return _graph->fromId(id, Item()); }
 …
   public:
     /// \brief The class represents the inverse of its owner (IdMap).
     ///
     /// The class represents the inverse of its owner (IdMap).
+    /// \brief This class represents the inverse of its owner (IdMap).
+    ///
+    /// This class represents the inverse of its owner (IdMap).
     /// \see inverse()
     class InverseMap {
 …
       ///
       /// Gives back the given item from its id.
-      ///
       Item operator[](int id) const { return _graph->fromId(id, Item());}
 …
     /// Gives back the inverse of the IdMap.
     InverseMap inverse() const { return InverseMap(*_graph);}
+  };
+  /// \brief General invertable graph-map type.
+  /// This type provides simple invertable graph-maps.
+  /// The InvertableMap wraps an arbitrary ReadWriteMap
+  };
+  /// \brief General invertable graph map type.
+  /// This class provides simple invertable graph maps.
+  /// It wraps an arbitrary \ref concepts::ReadWriteMap "ReadWriteMap"
   /// and if a key is set to a new value then store it
   /// in the inverse map.
 …
   /// with stl compatible forward iterator.
   ///
+  /// \tparam _Graph The graph type.
+  /// \tparam _Item The item type of the graph.
+  /// \tparam _Value The value type of the map.
+  /// \tparam GR The graph type.
+  /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or
+  /// \c GR::Edge).
+  /// \tparam V The value type of the map.
   ///
   /// \see IterableValueMap
   template <typename _Graph, typename _Item, typename _Value>
+  template <typename GR, typename K, typename V>
   class InvertableMap
     : protected ItemSetTraits<_Graph, _Item>::template Map<_Value>::Type {
+    : protected ItemSetTraits<GR, K>::template Map<V>::Type {
   private:
+    typedef typename ItemSetTraits<_Graph, _Item>::
+    template Map<_Value>::Type Map;
+    typedef _Graph Graph;
+    typedef std::map<_Value, _Item> Container;
+    typedef typename ItemSetTraits<GR, K>::
+      template Map<V>::Type Map;
+    typedef std::map<V, K> Container;
     Container _inv_map;
   public:
+    /// The key type of InvertableMap (Node, Arc, Edge).
+    typedef typename Map::Key Key;
+    /// The value type of the InvertableMap.
+    typedef typename Map::Value Value;
+    /// The graph type of InvertableMap.
+    typedef GR Graph;
+    /// The key type of InvertableMap (\c Node, \c Arc or \c Edge).
+    typedef K Item;
+    /// The key type of InvertableMap (\c Node, \c Arc or \c Edge).
+    typedef K Key;
+    /// The value type of InvertableMap.
+    typedef V Value;
     /// \brief Constructor.
     ///
+    /// Construct a new InvertableMap for the graph.
+    ///
+    /// Construct a new InvertableMap for the given graph.
     explicit InvertableMap(const Graph& graph) : Map(graph) {}
 …
     /// This iterator is an stl compatible forward
     /// iterator on the values of the map. The values can
+    /// be accessed in the [beginValue, endValue) range.
+    ///
+    /// be accessed in the <tt>[beginValue, endValue)</tt> range.
     class ValueIterator
       : public std::iterator<std::forward_iterator_tag, Value> {
 …
     /// Returns an stl compatible iterator to the
     /// first value of the map. The values of the
     /// map can be accessed in the [beginValue, endValue)
+    /// map can be accessed in the <tt>[beginValue, endValue)</tt>
     /// range.
     ValueIterator beginValue() const {
 …
     /// Returns an stl compatible iterator after the
     /// last value of the map. The values of the
     /// map can be accessed in the [beginValue, endValue)
+    /// map can be accessed in the <tt>[beginValue, endValue)</tt>
     /// range.
     ValueIterator endValue() const {
 …
+    }
     /// \brief The setter function of the map.
     ///
     /// Sets the mapped value.
+    /// \brief Sets the value associated with the given key.
+    ///
+    /// Sets the value associated with the given key.
     void set(const Key& key, const Value& val) {
       Value oldval = Map::operator[](key);
 …
+    }
     /// \brief The getter function of the map.
     ///
     /// It gives back the value associated with the key.
+    /// \brief Returns the value associated with the given key.
+    ///
+    /// Returns the value associated with the given key.
     typename MapTraits<Map>::ConstReturnValue
     operator[](const Key& key) const {
 …
   protected:
     /// \brief Erase the key from the map.
     ///
     /// Erase the key to the map. It is called by the
+    /// \brief Erase the key from the map and the inverse map.
+    ///
+    /// Erase the key from the map and the inverse map. It is called by the
     /// \c AlterationNotifier.
     virtual void erase(const Key& key) {
 …
+    }
     /// \brief Erase more keys from the map.
     ///
     /// Erase more keys from the map. It is called by the
+    /// \brief Erase more keys from the map and the inverse map.
+    ///
+    /// Erase more keys from the map and the inverse map. It is called by the
     /// \c AlterationNotifier.
     virtual void erase(const std::vector<Key>& keys) {
 …
+    }
     /// \brief Clear the keys from the map and inverse map.
     ///
     /// Clear the keys from the map and inverse map. It is called by the
+    /// \brief Clear the keys from the map and the inverse map.
+    ///
+    /// Clear the keys from the map and the inverse map. It is called by the
     /// \c AlterationNotifier.
     virtual void clear() {
 …
     ///
     /// The inverse of this map. The subscript operator of the map
     /// gives back always the item what was last assigned to the value.
+    /// gives back the item that was last assigned to the value.
     class InverseMap {
     public:
       /// \brief Constructor of the InverseMap.
+      /// \brief Constructor
       ///
       /// Constructor of the InverseMap.
 …
       /// \brief Subscript operator.
       ///
       /// Subscript operator. It gives back always the item
       /// what was last assigned to the value.
+      /// Subscript operator. It gives back the item
+      /// that was last assigned to the given value.
       Value operator[](const Key& key) const {
         return _inverted(key);
 …
     };
     /// \brief It gives back the just readable inverse map.
     ///
     /// It gives back the just readable inverse map.
+    /// \brief It gives back the read-only inverse map.
+    ///
+    /// It gives back the read-only inverse map.
     InverseMap inverse() const {
       return InverseMap(*this);
 …
   /// \brief Provides a mutable, continuous and unique descriptor for each
+  /// item in the graph.
+  ///
+  /// The DescriptorMap class provides a unique and continuous (but mutable)
+  /// descriptor (id) for each item of the same type (e.g. node) in the
+  /// graph. This id is <ul><li>\b unique: different items (nodes) get
+  /// different ids <li>\b continuous: the range of the ids is the set of
+  /// integers between 0 and \c n-1, where \c n is the number of the items of
+  /// this type (e.g. nodes) (so the id of a node can change if you delete an
+  /// other node, i.e. this id is mutable).  </ul> This map can be inverted
+  /// with its member class \c InverseMap, or with the \c operator() member.
+  ///
+  /// \tparam _Graph The graph class the \c DescriptorMap belongs to.
+  /// \tparam _Item The Item is the Key of the Map. It may be Node, Arc or
+  /// Edge.
+  template <typename _Graph, typename _Item>
+  /// item in a graph.
+  ///
+  /// DescriptorMap provides a unique and continuous (but mutable)
+  /// descriptor (id) for each item of the same type (\c Node, \c Arc or
+  /// \c Edge) in a graph. This id is
+  ///  - \b unique: different items get different ids,
+  ///  - \b continuous: the range of the ids is the set of integers
+  ///    between 0 and \c n-1, where \c n is the number of the items of
+  ///    this type (\c Node, \c Arc or \c Edge). So the id of an item can
+  ///    change if you delete an other item of the same type, i.e. this
+  ///    id is mutable.
+  ///
+  /// Thus this id is not (necessarily) the same as what can get using
+  /// the \c id() function of the graph or \ref IdMap.
+  /// This map can be inverted with its member class \c InverseMap,
+  /// or with the \c operator() member.
+  ///
+  /// \tparam GR The graph type.
+  /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or
+  /// \c GR::Edge).
+  ///
+  /// \see IdMap
+  template <typename GR, typename K>
   class DescriptorMap
     : protected ItemSetTraits<_Graph, _Item>::template Map<int>::Type {
     typedef _Item Item;
+    typedef typename ItemSetTraits<_Graph, _Item>::template Map<int>::Type Map;
   public:
     /// The graph class of DescriptorMap.
     typedef _Graph Graph;
     /// The key type of DescriptorMap (Node, Arc, Edge).
     typedef typename Map::Key Key;
+    : protected ItemSetTraits<GR, K>::template Map<int>::Type {
+    typedef typename ItemSetTraits<GR, K>::template Map<int>::Type Map;
+  public:
+    /// The graph type of DescriptorMap.
+    typedef GR Graph;
+    /// The key type of DescriptorMap (\c Node, \c Arc or \c Edge).
+    typedef K Item;
+    /// The key type of DescriptorMap (\c Node, \c Arc or \c Edge).
+    typedef K Key;
     /// The value type of DescriptorMap.
     typedef typename Map::Value Value;
+    typedef int Value;
     /// \brief Constructor.
     ///
     /// Constructor for descriptor map.
     explicit DescriptorMap(const Graph& _graph) : Map(_graph) {
+    explicit DescriptorMap(const Graph& gr) : Map(gr) {
       Item it;
       const typename Map::Notifier* nf = Map::notifier();
 …
   protected:
     /// \brief Add a new key to the map.
+    /// \brief Adds a new key to the map.
     ///
     /// Add a new key to the map. It is called by the
 …
   public:
     /// \brief The inverse map type of DescriptorMap.
     ///
 …
     class InverseMap {
     public:
       /// \brief Constructor of the InverseMap.
+      /// \brief Constructor
       ///
       /// Constructor of the InverseMap.
 …
       ///
       /// Subscript operator. It gives back the item
       /// that the descriptor belongs to currently.
+      /// that the descriptor currently belongs to.
       Value operator[](const Key& key) const {
         return _inverted(key);
 …
   };
+  /// \brief Returns the source of the given arc.
+  ///
+  /// The SourceMap gives back the source Node of the given arc.
+  /// \brief Map of the source nodes of arcs in a digraph.
+  ///
+  /// SourceMap provides access for the source node of each arc in a digraph,
+  /// which is returned by the \c source() function of the digraph.
+  /// \tparam GR The digraph type.
   /// \see TargetMap
   template <typename Digraph>
+  template <typename GR>
   class SourceMap {
   public:
+    typedef typename Digraph::Node Value;
+    typedef typename Digraph::Arc Key;
+    ///\e
+    typedef typename GR::Arc Key;
+    ///\e
+    typedef typename GR::Node Value;
     /// \brief Constructor
     ///
     /// Constructor
+    /// Constructor.
     /// \param digraph The digraph that the map belongs to.
+    explicit SourceMap(const Digraph& digraph) : _digraph(digraph) {}
+    /// \brief The subscript operator.
+    ///
+    /// The subscript operator.
+    /// \param arc The arc
+    /// \return The source of the arc
+    explicit SourceMap(const GR& digraph) : _graph(digraph) {}
+    /// \brief Returns the source node of the given arc.
+    ///
+    /// Returns the source node of the given arc.
     Value operator[](const Key& arc) const {
       return _digraph.source(arc);
+      return _graph.source(arc);
+    }
   private:
     const Digraph& _digraph;
+    const GR& _graph;
   };
 …
   /// This function just returns an \c SourceMap class.
   /// \relates SourceMap
+  template <typename Digraph>
+  inline SourceMap<Digraph> sourceMap(const Digraph& digraph) {
+    return SourceMap<Digraph>(digraph);
+  }
+  /// \brief Returns the target of the given arc.
+  ///
+  /// The TargetMap gives back the target Node of the given arc.
+  template <typename GR>
+  inline SourceMap<GR> sourceMap(const GR& graph) {
+    return SourceMap<GR>(graph);
+  }
+  /// \brief Map of the target nodes of arcs in a digraph.
+  ///
+  /// TargetMap provides access for the target node of each arc in a digraph,
+  /// which is returned by the \c target() function of the digraph.
+  /// \tparam GR The digraph type.
   /// \see SourceMap
   template <typename Digraph>
+  template <typename GR>
   class TargetMap {
   public:
+    typedef typename Digraph::Node Value;
+    typedef typename Digraph::Arc Key;
+    ///\e
+    typedef typename GR::Arc Key;
+    ///\e
+    typedef typename GR::Node Value;
     /// \brief Constructor
     ///
     /// Constructor
+    /// Constructor.
     /// \param digraph The digraph that the map belongs to.
+    explicit TargetMap(const Digraph& digraph) : _digraph(digraph) {}
+    /// \brief The subscript operator.
+    ///
+    /// The subscript operator.
+    /// \param e The arc
+    /// \return The target of the arc
+    explicit TargetMap(const GR& digraph) : _graph(digraph) {}
+    /// \brief Returns the target node of the given arc.
+    ///
+    /// Returns the target node of the given arc.
     Value operator[](const Key& e) const {
       return _digraph.target(e);
+      return _graph.target(e);
+    }
   private:
     const Digraph& _digraph;
+    const GR& _graph;
   };
 …
   /// This function just returns a \c TargetMap class.
   /// \relates TargetMap
+  template <typename Digraph>
+  inline TargetMap<Digraph> targetMap(const Digraph& digraph) {
+    return TargetMap<Digraph>(digraph);
+  }
+  /// \brief Returns the "forward" directed arc view of an edge.
+  ///
+  /// Returns the "forward" directed arc view of an edge.
+  template <typename GR>
+  inline TargetMap<GR> targetMap(const GR& graph) {
+    return TargetMap<GR>(graph);
+  }
+  /// \brief Map of the "forward" directed arc view of edges in a graph.
+  ///
+  /// ForwardMap provides access for the "forward" directed arc view of
+  /// each edge in a graph, which is returned by the \c direct() function
+  /// of the graph with \c true parameter.
+  /// \tparam GR The graph type.
   /// \see BackwardMap
   template <typename Graph>
+  template <typename GR>
   class ForwardMap {
   public:
     typedef typename Graph::Arc Value;
     typedef typename Graph::Edge Key;
+    typedef typename GR::Arc Value;
+    typedef typename GR::Edge Key;
     /// \brief Constructor
     ///
     /// Constructor
+    /// Constructor.
     /// \param graph The graph that the map belongs to.
+    explicit ForwardMap(const Graph& graph) : _graph(graph) {}
+    /// \brief The subscript operator.
+    ///
+    /// The subscript operator.
+    /// \param key An edge
+    /// \return The "forward" directed arc view of edge
+    explicit ForwardMap(const GR& graph) : _graph(graph) {}
+    /// \brief Returns the "forward" directed arc view of the given edge.
+    ///
+    /// Returns the "forward" directed arc view of the given edge.
     Value operator[](const Key& key) const {
       return _graph.direct(key, true);
 …
   private:
     const Graph& _graph;
+    const GR& _graph;
   };
 …
   /// This function just returns an \c ForwardMap class.
   /// \relates ForwardMap
+  template <typename Graph>
+  inline ForwardMap<Graph> forwardMap(const Graph& graph) {
+    return ForwardMap<Graph>(graph);
+  }
+  /// \brief Returns the "backward" directed arc view of an edge.
+  ///
+  /// Returns the "backward" directed arc view of an edge.
+  template <typename GR>
+  inline ForwardMap<GR> forwardMap(const GR& graph) {
+    return ForwardMap<GR>(graph);
+  }
+  /// \brief Map of the "backward" directed arc view of edges in a graph.
+  ///
+  /// BackwardMap provides access for the "backward" directed arc view of
+  /// each edge in a graph, which is returned by the \c direct() function
+  /// of the graph with \c false parameter.
+  /// \tparam GR The graph type.
   /// \see ForwardMap
   template <typename Graph>
+  template <typename GR>
   class BackwardMap {
   public:
     typedef typename Graph::Arc Value;
     typedef typename Graph::Edge Key;
+    typedef typename GR::Arc Value;
+    typedef typename GR::Edge Key;
     /// \brief Constructor
     ///
     /// Constructor
+    /// Constructor.
     /// \param graph The graph that the map belongs to.
+    explicit BackwardMap(const Graph& graph) : _graph(graph) {}
+    /// \brief The subscript operator.
+    ///
+    /// The subscript operator.
+    /// \param key An edge
+    /// \return The "backward" directed arc view of edge
+    explicit BackwardMap(const GR& graph) : _graph(graph) {}
+    /// \brief Returns the "backward" directed arc view of the given edge.
+    ///
+    /// Returns the "backward" directed arc view of the given edge.
     Value operator[](const Key& key) const {
       return _graph.direct(key, false);
 …
   private:
     const Graph& _graph;
+    const GR& _graph;
   };
 …
   /// This function just returns a \c BackwardMap class.
   /// \relates BackwardMap
+  template <typename Graph>
+  inline BackwardMap<Graph> backwardMap(const Graph& graph) {
+    return BackwardMap<Graph>(graph);
+  }
+  /// \brief Potential difference map
+  ///
+  /// If there is an potential map on the nodes then we
+  /// can get an arc map as we get the substraction of the
+  /// values of the target and source.
+  template <typename Digraph, typename NodeMap>
+  class PotentialDifferenceMap {
+  public:
+    typedef typename Digraph::Arc Key;
+    typedef typename NodeMap::Value Value;
+    /// \brief Constructor
+    ///
+    /// Contructor of the map
+    explicit PotentialDifferenceMap(const Digraph& digraph,
+                                    const NodeMap& potential)
+      : _digraph(digraph), _potential(potential) {}
+    /// \brief Const subscription operator
+    ///
+    /// Const subscription operator
+    Value operator[](const Key& arc) const {
+      return _potential[_digraph.target(arc)] -
+        _potential[_digraph.source(arc)];
+    }
+  private:
+    const Digraph& _digraph;
+    const NodeMap& _potential;
+  };
+  /// \brief Returns a PotentialDifferenceMap.
+  ///
+  /// This function just returns a PotentialDifferenceMap.
+  /// \relates PotentialDifferenceMap
+  template <typename Digraph, typename NodeMap>
+  PotentialDifferenceMap<Digraph, NodeMap>
+  potentialDifferenceMap(const Digraph& digraph, const NodeMap& potential) {
+    return PotentialDifferenceMap<Digraph, NodeMap>(digraph, potential);
+  }
+  /// \brief Map of the node in-degrees.
+  template <typename GR>
+  inline BackwardMap<GR> backwardMap(const GR& graph) {
+    return BackwardMap<GR>(graph);
+  }
+  /// \brief Map of the in-degrees of nodes in a digraph.
   ///
   /// This map returns the in-degree of a node. Once it is constructed,
   /// the degrees are stored in a standard NodeMap, so each query is done
+  /// the degrees are stored in a standard \c NodeMap, so each query is done
   /// in constant time. On the other hand, the values are updated automatically
   /// whenever the digraph changes.
   ///
+  /// \warning Besides addNode() and addArc(), a digraph structure may provide
+  /// alternative ways to modify the digraph. The correct behavior of InDegMap
+  /// is not guarantied if these additional features are used. For example
+  /// the functions \ref ListDigraph::changeSource() "changeSource()",
+  /// \warning Besides \c addNode() and \c addArc(), a digraph structure
+  /// may provide alternative ways to modify the digraph.
+  /// The correct behavior of InDegMap is not guarantied if these additional
+  /// features are used. For example the functions
+  /// \ref ListDigraph::changeSource() "changeSource()",
   /// \ref ListDigraph::changeTarget() "changeTarget()" and
   /// \ref ListDigraph::reverseArc() "reverseArc()"
 …
   ///
   /// \sa OutDegMap
+  template <typename _Digraph>
+  template <typename GR>
   class InDegMap
     : protected ItemSetTraits<_Digraph, typename _Digraph::Arc>
+    : protected ItemSetTraits<GR, typename GR::Arc>
       ::ItemNotifier::ObserverBase {
   public:
+    typedef _Digraph Digraph;
+    /// The digraph type
+    typedef GR Digraph;
+    /// The key type
+    typedef typename Digraph::Node Key;
+    /// The value type
     typedef int Value;
-    typedef typename Digraph::Node Key;
     typedef typename ItemSetTraits<Digraph, typename Digraph::Arc>
 …
     /// \brief Constructor.
     ///
     /// Constructor for creating in-degree map.
     explicit InDegMap(const Digraph& digraph)
       : _digraph(digraph), _deg(digraph) {
+    /// Constructor for creating an in-degree map.
+    explicit InDegMap(const Digraph& graph)
+      : _digraph(graph), _deg(graph) {
       Parent::attach(_digraph.notifier(typename Digraph::Arc()));
 …
+    }
+    /// \brief Gives back the in-degree of a Node.
+    ///
     /// Gives back the in-degree of a Node.
     int operator[](const Key& key) const {
 …
   };
   /// \brief Map of the node out-degrees.
+  /// \brief Map of the out-degrees of nodes in a digraph.
   ///
   /// This map returns the out-degree of a node. Once it is constructed,
   /// the degrees are stored in a standard NodeMap, so each query is done
+  /// the degrees are stored in a standard \c NodeMap, so each query is done
   /// in constant time. On the other hand, the values are updated automatically
   /// whenever the digraph changes.
   ///
+  /// \warning Besides addNode() and addArc(), a digraph structure may provide
+  /// alternative ways to modify the digraph. The correct behavior of OutDegMap
+  /// is not guarantied if these additional features are used. For example
+  /// the functions \ref ListDigraph::changeSource() "changeSource()",
+  /// \warning Besides \c addNode() and \c addArc(), a digraph structure
+  /// may provide alternative ways to modify the digraph.
+  /// The correct behavior of OutDegMap is not guarantied if these additional
+  /// features are used. For example the functions
+  /// \ref ListDigraph::changeSource() "changeSource()",
   /// \ref ListDigraph::changeTarget() "changeTarget()" and
   /// \ref ListDigraph::reverseArc() "reverseArc()"
 …
   ///
   /// \sa InDegMap
+  template <typename _Digraph>
+  template <typename GR>
   class OutDegMap
     : protected ItemSetTraits<_Digraph, typename _Digraph::Arc>
+    : protected ItemSetTraits<GR, typename GR::Arc>
       ::ItemNotifier::ObserverBase {
   public:
+    typedef _Digraph Digraph;
+    /// The digraph type
+    typedef GR Digraph;
+    /// The key type
+    typedef typename Digraph::Node Key;
+    /// The value type
     typedef int Value;
-    typedef typename Digraph::Node Key;
     typedef typename ItemSetTraits<Digraph, typename Digraph::Arc>
 …
     /// \brief Constructor.
     ///
     /// Constructor for creating out-degree map.
     explicit OutDegMap(const Digraph& digraph)
       : _digraph(digraph), _deg(digraph) {
+    /// Constructor for creating an out-degree map.
+    explicit OutDegMap(const Digraph& graph)
+      : _digraph(graph), _deg(graph) {
       Parent::attach(_digraph.notifier(typename Digraph::Arc()));
 …
+    }
+    /// \brief Gives back the out-degree of a Node.
+    ///
     /// Gives back the out-degree of a Node.
     int operator[](const Key& key) const {
 …
   };
+  /// \brief Potential difference map
+  ///
+  /// 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)].
+  /// \endcode
+  /// \tparam GR The digraph type.
+  /// \tparam POT A node map storing the potentials.
+  template <typename GR, typename POT>
+  class PotentialDifferenceMap {
+  public:
+    /// Key type
+    typedef typename GR::Arc Key;
+    /// Value type
+    typedef typename POT::Value Value;
+    /// \brief Constructor
+    ///
+    /// Contructor of the map.
+    explicit PotentialDifferenceMap(const GR& gr,
+                                    const POT& potential)
+      : _digraph(gr), _potential(potential) {}
+    /// \brief Returns the potential difference for the given arc.
+    ///
+    /// Returns the potential difference for the given arc, i.e.
+    /// \code
+    ///   potential[gr.target(arc)] - potential[gr.source(arc)].
+    /// \endcode
+    Value operator[](const Key& arc) const {
+      return _potential[_digraph.target(arc)] -
+        _potential[_digraph.source(arc)];
+    }
+  private:
+    const GR& _digraph;
+    const POT& _potential;
+  };
+  /// \brief Returns a PotentialDifferenceMap.
+  ///
+  /// This function just returns a PotentialDifferenceMap.
+  /// \relates PotentialDifferenceMap
+  template <typename GR, typename POT>
+  PotentialDifferenceMap<GR, POT>
+  potentialDifferenceMap(const GR& gr, const POT& potential) {
+    return PotentialDifferenceMap<GR, POT>(gr, potential);
+  }
   /// @}
+}

lemon/max_matching.h

-                      r440
+                      r559
   /// decomposition() after running the algorithm.
   ///
   /// \param _Graph The graph type the algorithm runs on.
   template <typename _Graph>
+  /// \param GR The graph type the algorithm runs on.
+  template <typename GR>
   class MaxMatching {
   public:
     typedef _Graph Graph;
+    typedef GR Graph;
     typedef typename Graph::template NodeMap<typename Graph::Arc>
     MatchingMap;
 …
     /// map must have the property that there are no two incident edges
     /// with true value, ie. it contains a matching.
     /// \return %True if the map contains a matching.
+    /// \return \c true if the map contains a matching.
     template <typename MatchingMap>
     bool matchingInit(const MatchingMap& matching) {
 …
   /// maximum weighted matching algorithm. The implementation is based
   /// on extensive use of priority queues and provides
   /// \f$O(nm\log(n))\f$ time complexity.
+  /// \f$O(nm\log n)\f$ time complexity.
   ///
   /// The maximum weighted matching problem is to find undirected
 …
   /// of a blossom. If the value type is integral then the dual
   /// solution is multiplied by \ref MaxWeightedMatching::dualScale "4".
   template <typename _Graph,
             typename _WeightMap = typename _Graph::template EdgeMap<int> >
+  template <typename GR,
+            typename WM = typename GR::template EdgeMap<int> >
   class MaxWeightedMatching {
   public:
+    typedef _Graph Graph;
+    typedef _WeightMap WeightMap;
+    ///\e
+    typedef GR Graph;
+    ///\e
+    typedef WM WeightMap;
+    ///\e
     typedef typename WeightMap::Value Value;
 …
   /// maximum weighted perfect matching algorithm. The implementation
   /// is based on extensive use of priority queues and provides
   /// \f$O(nm\log(n))\f$ time complexity.
+  /// \f$O(nm\log n)\f$ time complexity.
   ///
   /// The maximum weighted matching problem is to find undirected
 …
   /// of a blossom. If the value type is integral then the dual
   /// solution is multiplied by \ref MaxWeightedMatching::dualScale "4".
   template <typename _Graph,
             typename _WeightMap = typename _Graph::template EdgeMap<int> >
+  template <typename GR,
+            typename WM = typename GR::template EdgeMap<int> >
   class MaxWeightedPerfectMatching {
   public:
     typedef _Graph Graph;
     typedef _WeightMap WeightMap;
+    typedef GR Graph;
+    typedef WM WeightMap;
     typedef typename WeightMap::Value Value;

lemon/min_cost_arborescence.h

-                      r501
+                      r559
   ///
   /// Default traits class for MinCostArborescence class.
   /// \param _Digraph Digraph type.
   /// \param _CostMap Type of cost map.
   template <class _Digraph, class _CostMap>
+  /// \param GR Digraph type.
+  /// \param CM Type of cost map.
+  template <class GR, class CM>
   struct MinCostArborescenceDefaultTraits{
     /// \brief The digraph type the algorithm runs on.
     typedef _Digraph Digraph;
+    typedef GR Digraph;
     /// \brief The type of the map that stores the arc costs.
 …
     /// The type of the map that stores the arc costs.
     /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
     typedef _CostMap CostMap;
+    typedef CM CostMap;
     /// \brief The value type of the costs.
 …
     typedef typename Digraph::template ArcMap<bool> ArborescenceMap;
     /// \brief Instantiates a ArborescenceMap.
     ///
     /// This function instantiates a \ref ArborescenceMap.
+    /// \brief Instantiates a \c ArborescenceMap.
+    ///
+    /// This function instantiates a \c ArborescenceMap.
     /// \param digraph is the graph, to which we would like to
     /// calculate the ArborescenceMap.
+    /// calculate the \c ArborescenceMap.
     static ArborescenceMap *createArborescenceMap(const Digraph &digraph){
       return new ArborescenceMap(digraph);
+    }
     /// \brief The type of the PredMap
     ///
     /// The type of the PredMap. It is a node map with an arc value type.
+    /// \brief The type of the \c PredMap
+    ///
+    /// The type of the \c PredMap. It is a node map with an arc value type.
     typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
     /// \brief Instantiates a PredMap.
     ///
     /// This function instantiates a \ref PredMap.
     /// \param _digraph is the digraph, to which we would like to define the
     /// PredMap.
+    /// \brief Instantiates a \c PredMap.
+    ///
+    /// This function instantiates a \c PredMap.
+    /// \param digraph The digraph to which we would like to define the
+    /// \c PredMap.
     static PredMap *createPredMap(const Digraph &digraph){
       return new PredMap(digraph);
 …
   /// the minimum cost subgraph which are union of arborescences with the
   /// given sources and spans all the nodes which are reachable from the
   /// sources. The time complexity of the algorithm is \f$ O(n^2+e) \f$.
+  /// sources. The time complexity of the algorithm is O(n<sup>2</sup>+e).
   ///
   /// The algorithm provides also an optimal dual solution, therefore
   /// the optimality of the solution can be checked.
   ///
   /// \param _Digraph The digraph type the algorithm runs on. The default value
+  /// \param GR The digraph type the algorithm runs on. The default value
   /// is \ref ListDigraph.
   /// \param _CostMap This read-only ArcMap determines the costs of the
+  /// \param CM This read-only ArcMap determines the costs of the
   /// arcs. It is read once for each arc, so the map may involve in
   /// relatively time consuming process to compute the arc cost if
   /// it is necessary. The default map type is \ref
   /// concepts::Digraph::ArcMap "Digraph::ArcMap<int>".
   /// \param _Traits Traits class to set various data types used
+  /// \param TR Traits class to set various data types used
   /// by the algorithm. The default traits class is
   /// \ref MinCostArborescenceDefaultTraits
   /// "MinCostArborescenceDefaultTraits<_Digraph, _CostMap>".  See \ref
+  /// "MinCostArborescenceDefaultTraits<GR, CM>".  See \ref
   /// MinCostArborescenceDefaultTraits for the documentation of a
   /// MinCostArborescence traits class.
-  ///
-  /// \author Balazs Dezso
 #ifndef DOXYGEN
   template <typename _Digraph = ListDigraph,
             typename _CostMap = typename _Digraph::template ArcMap<int>,
             typename _Traits =
             MinCostArborescenceDefaultTraits<_Digraph, _CostMap> >
+  template <typename GR = ListDigraph,
+            typename CM = typename GR::template ArcMap<int>,
+            typename TR =
+              MinCostArborescenceDefaultTraits<GR, CM> >
 #else
   template <typename _Digraph, typename _CostMap, typedef _Traits>
+  template <typename GR, typename CM, typedef TR>
 #endif
   class MinCostArborescence {
 …
     /// The traits.
     typedef _Traits Traits;
+    typedef TR Traits;
     /// The type of the underlying digraph.
     typedef typename Traits::Digraph Digraph;
 …
     /// \brief Constructor.
     ///
     /// \param _digraph The digraph the algorithm will run on.
     /// \param _cost The cost map used by the algorithm.
+    /// \param digraph The digraph the algorithm will run on.
+    /// \param cost The cost map used by the algorithm.
     MinCostArborescence(const Digraph& digraph, const CostMap& cost)
       : _digraph(&digraph), _cost(&cost), _pred(0), local_pred(false),
 …
     ///
     /// Sets the arborescence map.
     /// \return \c (*this)
+    /// \return <tt>(*this)</tt>
     MinCostArborescence& arborescenceMap(ArborescenceMap& m) {
       if (local_arborescence) {
 …
     ///
     /// Sets the arborescence map.
     /// \return \c (*this)
+    /// \return <tt>(*this)</tt>
     MinCostArborescence& predMap(PredMap& m) {
       if (local_pred) {

lemon/path.h

-                      r517
+                      r559
   ///
   /// A structure for representing directed path in a digraph.
   /// \tparam _Digraph The digraph type in which the path is.
+  /// \tparam GR The digraph type in which the path is.
   ///
   /// In a sense, the path can be treated as a list of arcs. The
 …
   /// implementation uses two vectors for storing the front and back
   /// insertions.
   template <typename _Digraph>
+  template <typename GR>
   class Path {
   public:
     typedef _Digraph Digraph;
+    typedef GR Digraph;
     typedef typename Digraph::Arc Arc;
 …
     /// \brief The nth arc.
     ///
     /// \pre n is in the [0..length() - 1] range
+    /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
     const Arc& nth(int n) const {
       return n < int(head.size()) ? *(head.rbegin() + n) :
 …
     /// \brief Initialize arc iterator to point to the nth arc
     ///
     /// \pre n is in the [0..length() - 1] range
+    /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
     ArcIt nthIt(int n) const {
       return ArcIt(*this, n);
 …
   ///
   /// A structure for representing directed path in a digraph.
   /// \tparam _Digraph The digraph type in which the path is.
+  /// \tparam GR The digraph type in which the path is.
   ///
   /// In a sense, the path can be treated as a list of arcs. The
 …
   /// then the \c Path type because it use just one vector for the
   /// arcs.
   template <typename _Digraph>
+  template <typename GR>
   class SimplePath {
   public:
     typedef _Digraph Digraph;
+    typedef GR Digraph;
     typedef typename Digraph::Arc Arc;
 …
     /// \brief The nth arc.
     ///
     /// \pre n is in the [0..length() - 1] range
+    /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
     const Arc& nth(int n) const {
       return data[n];
 …
   ///
   /// A structure for representing directed path in a digraph.
   /// \tparam _Digraph The digraph type in which the path is.
+  /// \tparam GR The digraph type in which the path is.
   ///
   /// In a sense, the path can be treated as a list of arcs. The
 …
   /// time. The front and back insertion and erasure is O(1) time
   /// and it can be splited and spliced in O(1) time.
   template <typename _Digraph>
+  template <typename GR>
   class ListPath {
   public:
     typedef _Digraph Digraph;
+    typedef GR Digraph;
     typedef typename Digraph::Arc Arc;
 …
     ///
     /// This function looks for the nth arc in O(n) time.
     /// \pre n is in the [0..length() - 1] range
+    /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
     const Arc& nth(int n) const {
       Node *node = first;
 …
   ///
   /// A structure for representing directed path in a digraph.
   /// \tparam _Digraph The digraph type in which the path is.
+  /// \tparam GR The digraph type in which the path is.
   ///
   /// In a sense, the path can be treated as a list of arcs. The
 …
   /// it is intented to be
   /// used when you want to store a large number of paths.
   template <typename _Digraph>
+  template <typename GR>
   class StaticPath {
   public:
     typedef _Digraph Digraph;
+    typedef GR Digraph;
     typedef typename Digraph::Arc Arc;
 …
     /// \brief The nth arc.
     ///
     /// \pre n is in the [0..length() - 1] range
+    /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
     const Arc& nth(int n) const {
       return arcs[n];

lemon/preflow.h

-                      r503
+                      r559
   /// Default traits class of Preflow class.
   /// \tparam GR Digraph type.
   /// \tparam CM Capacity map type.
   template <typename GR, typename CM>
+  /// \tparam CAP Capacity map type.
+  template <typename GR, typename CAP>
   struct PreflowDefaultTraits {
 …
     /// The type of the map that stores the arc capacities.
     /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
     typedef CM CapacityMap;
+    typedef CAP CapacityMap;
     /// \brief The type of the flow values.
 …
   ///
   /// This class provides an implementation of Goldberg-Tarjan's \e preflow
+  /// \e push-relabel algorithm producing a flow of maximum value in a
+  /// digraph. The preflow algorithms are the fastest known maximum
+  /// \e push-relabel algorithm producing a \ref max_flow
+  /// "flow of maximum value" in a digraph.
+  /// The preflow algorithms are the fastest known maximum
   /// flow algorithms. The current implementation use a mixture of the
   /// \e "highest label" and the \e "bound decrease" heuristics.
 …
   ///
   /// \tparam GR The type of the digraph the algorithm runs on.
   /// \tparam CM The type of the capacity map. The default map
+  /// \tparam CAP The type of the capacity map. The default map
   /// type is \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
 #ifdef DOXYGEN
   template <typename GR, typename CM, typename TR>
+  template <typename GR, typename CAP, typename TR>
 #else
   template <typename GR,
             typename CM = typename GR::template ArcMap<int>,
             typename TR = PreflowDefaultTraits<GR, CM> >
+            typename CAP = typename GR::template ArcMap<int>,
+            typename TR = PreflowDefaultTraits<GR, CAP> >
 #endif
   class Preflow {
 …
     ///@{
     template <typename _FlowMap>
+    template <typename T>
     struct SetFlowMapTraits : public Traits {
       typedef _FlowMap FlowMap;
+      typedef T FlowMap;
       static FlowMap *createFlowMap(const Digraph&) {
         LEMON_ASSERT(false, "FlowMap is not initialized");
 …
     /// \ref named-templ-param "Named parameter" for setting FlowMap
     /// type.
     template <typename _FlowMap>
+    template <typename T>
     struct SetFlowMap
       : public Preflow<Digraph, CapacityMap, SetFlowMapTraits<_FlowMap> > {
+      : public Preflow<Digraph, CapacityMap, SetFlowMapTraits<T> > {
       typedef Preflow<Digraph, CapacityMap,
                       SetFlowMapTraits<_FlowMap> > Create;
+                      SetFlowMapTraits<T> > Create;
     };
     template <typename _Elevator>
+    template <typename T>
     struct SetElevatorTraits : public Traits {
       typedef _Elevator Elevator;
+      typedef T Elevator;
       static Elevator *createElevator(const Digraph&, int) {
         LEMON_ASSERT(false, "Elevator is not initialized");
 …
     /// \ref run() or \ref init().
     /// \sa SetStandardElevator
     template <typename _Elevator>
+    template <typename T>
     struct SetElevator
       : public Preflow<Digraph, CapacityMap, SetElevatorTraits<_Elevator> > {
+      : public Preflow<Digraph, CapacityMap, SetElevatorTraits<T> > {
       typedef Preflow<Digraph, CapacityMap,
                       SetElevatorTraits<_Elevator> > Create;
+                      SetElevatorTraits<T> > Create;
     };
     template <typename _Elevator>
+    template <typename T>
     struct SetStandardElevatorTraits : public Traits {
       typedef _Elevator Elevator;
+      typedef T Elevator;
       static Elevator *createElevator(const Digraph& digraph, int max_level) {
         return new Elevator(digraph, max_level);
 …
     /// before calling \ref run() or \ref init().
     /// \sa SetElevator
     template <typename _Elevator>
+    template <typename T>
     struct SetStandardElevator
       : public Preflow<Digraph, CapacityMap,
                        SetStandardElevatorTraits<_Elevator> > {
+                       SetStandardElevatorTraits<T> > {
       typedef Preflow<Digraph, CapacityMap,
                       SetStandardElevatorTraits<_Elevator> > Create;
+                      SetStandardElevatorTraits<T> > Create;
     };
 …
     ///
     /// \note This function calls \ref minCut() for each node, so it runs in
     /// \f$O(n)\f$ time.
+    /// O(n) time.
     ///
     /// \pre Either \ref run() or \ref init() must be called before

lemon/radix_sort.h

-                      r444
+                      r559
   ///
   /// This is a special quick sort algorithm where the pivot
   /// values to split the items are choosen to be \f$ 2^k \f$ for each \c k.
   /// Therefore, the time complexity of the
   /// algorithm is \f$ O(\log(c)n) \f$ and it uses \f$ O(\log(c)) \f$,
   /// additional space, where \c c is the maximal value and \c n is the
   /// number of the items in the container.
+  /// values to split the items are choosen to be 2<sup>k</sup>
+  /// for each \c k.
+  /// Therefore, the time complexity of the algorithm is O(log(c)*n) and
+  /// it uses O(log(c)) additional space, where \c c is the maximal value
+  /// and \c n is the number of the items in the container.
   ///
   /// \param first The begin of the given range.
 …
   /// byte-by-byte. First, it counts how many times a byte value occurs
   /// in the container, then it copies the corresponding items to
   /// another container in asceding order in \c O(n) time.
   ///
   /// The time complexity of the algorithm is \f$ O(\log(c)n) \f$ and
   /// it uses \f$ O(n) \f$, additional space, where \c c is the
+  /// another container in asceding order in O(n) time.
+  ///
+  /// The time complexity of the algorithm is O(log(c)*n) and
+  /// it uses O(n) additional space, where \c c is the
   /// maximal value and \c n is the number of the items in the
   /// container.

lemon/random.h

-                      r517
+                      r559
     /// function with the <tt>/dev/urandom</tt> file. If it does not success,
     /// it uses the \c seedFromTime().
     /// \return Currently always true.
+    /// \return Currently always \c true.
     bool seed() {
 #ifndef WIN32
 …
     /// \param file The source file
     /// \param offset The offset, from the file read.
     /// \return True when the seeding successes.
+    /// \return \c true when the seeding successes.
 #ifndef WIN32
     bool seedFromFile(const std::string& file = "/dev/urandom", int offset = 0)
 …
     /// current process id and the current time for initialize the
     /// random sequence.
     /// \return Currently always true.
+    /// \return Currently always \c true.
     bool seedFromTime() {
 #ifndef WIN32

lemon/smart_graph.h

-                      r440
+                      r559
     ///Add a new node to the digraph.
     /// \return the new node.
     ///
+    /// Add a new node to the digraph.
+    /// \return The new node.
     Node addNode() { return Parent::addNode(); }
 …
     ///Add a new arc to the digraph with source node \c s
     ///and target node \c t.
     ///\return the new arc.
+    ///\return The new arc.
     Arc addArc(const Node& s, const Node& t) {
       return Parent::addArc(s, t);
 …
     ///Add a new node to the graph.
     /// \return the new node.
     ///
+    /// Add a new node to the graph.
+    /// \return The new node.
     Node addNode() { return Parent::addNode(); }
 …
     ///Add a new edge to the graph with node \c s
     ///and \c t.
     ///\return the new edge.
+    ///\return The new edge.
     Edge addEdge(const Node& s, const Node& t) {
       return Parent::addEdge(s, t);

lemon/suurballe.h

-                      r519
+                      r559
   /// \ref CapacityScaling "successive shortest path" algorithm.
   ///
   /// \tparam Digraph The digraph type the algorithm runs on.
+  /// \tparam GR The digraph type the algorithm runs on.
   /// The default value is \c ListDigraph.
   /// \tparam LengthMap The type of the length (cost) map.
+  /// \tparam LEN The type of the length (cost) map.
   /// The default value is <tt>Digraph::ArcMap<int></tt>.
   ///
 …
   /// with \ref SplitNodes.
 #ifdef DOXYGEN
   template <typename Digraph, typename LengthMap>
+  template <typename GR, typename LEN>
 #else
   template < typename Digraph = ListDigraph,
              typename LengthMap = typename Digraph::template ArcMap<int> >
+  template < typename GR = ListDigraph,
+             typename LEN = typename GR::template ArcMap<int> >
 #endif
   class Suurballe
+  {
+    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
+    TEMPLATE_DIGRAPH_TYPEDEFS(GR);
+    typedef ConstMap<Arc, int> ConstArcMap;
+    typedef typename GR::template NodeMap<Arc> PredMap;
+  public:
+    /// The type of the digraph the algorithm runs on.
+    typedef GR Digraph;
+    /// The type of the length map.
+    typedef LEN LengthMap;
+    /// The type of the lengths.
     typedef typename LengthMap::Value Length;
-    typedef ConstMap<Arc, int> ConstArcMap;
-    typedef typename Digraph::template NodeMap<Arc> PredMap;
-  public:
     /// The type of the flow map.
     typedef typename Digraph::template ArcMap<int> FlowMap;
 …
     /// the found arc-disjoint paths.
     ///
     /// \return \c (*this)
+    /// \return <tt>(*this)</tt>
     Suurballe& flowMap(FlowMap &map) {
       if (_local_flow) {
 …
     /// minimum cost flow problem.
     ///
     /// \return \c (*this)
+    /// \return <tt>(*this)</tt>
     Suurballe& potentialMap(PotentialMap &map) {
       if (_local_potential) {
 …
     ///
     /// This function returns the total length (cost) of the found paths
     /// (flow). The complexity of the function is \f$ O(e) \f$.
+    /// (flow). The complexity of the function is O(e).
     ///
     /// \pre \ref run() or \ref findFlow() must be called before using

lemon/unionfind.h

-                      r440
+                      r559
   /// \pre You need to add all the elements by the \ref insert()
   /// method.
   template <typename _ItemIntMap>
+  template <typename IM>
   class UnionFind {
   public:
+    typedef _ItemIntMap ItemIntMap;
+    ///\e
+    typedef IM ItemIntMap;
+    ///\e
     typedef typename ItemIntMap::Key Item;
 …
   /// method.
   ///
   template <typename _ItemIntMap>
+  template <typename IM>
   class UnionFindEnum {
   public:
+    typedef _ItemIntMap ItemIntMap;
+    ///\e
+    typedef IM ItemIntMap;
+    ///\e
     typedef typename ItemIntMap::Key Item;
 …
   /// \pre You need to add all the elements by the \ref insert()
   /// method.
   template <typename _ItemIntMap>
+  template <typename IM>
   class ExtendFindEnum {
   public:
+    typedef _ItemIntMap ItemIntMap;
+    ///\e
+    typedef IM ItemIntMap;
+    ///\e
     typedef typename ItemIntMap::Key Item;
 …
   /// \pre You need to add all the elements by the \ref insert()
   /// method.
+  ///
+  template <typename _Value, typename _ItemIntMap,
+            typename _Comp = std::less<_Value> >
+  template <typename V, typename IM, typename Comp = std::less<V> >
   class HeapUnionFind {
   public:
+    typedef _Value Value;
+    typedef typename _ItemIntMap::Key Item;
+    typedef _ItemIntMap ItemIntMap;
+    typedef _Comp Comp;
+    ///\e
+    typedef V Value;
+    ///\e
+    typedef typename IM::Key Item;
+    ///\e
+    typedef IM ItemIntMap;
+    ///\e
+    typedef Comp Compare;
   private:
 …
     /// \brief Gives back the priority of the current item.
     ///
     /// \return Gives back the priority of the current item.
+    /// Gives back the priority of the current item.
     const Value& operator[](const Item& item) const {
       return nodes[index[item]].prio;
 …
     /// \brief Gives back the minimum priority of the class.
     ///
     /// \return Gives back the minimum priority of the class.
+    /// Gives back the minimum priority of the class.
     const Value& classPrio(int cls) const {
       return nodes[~(classes[cls].parent)].prio;
 …
     /// \brief Gives back a representant item of the class.
     ///
+    /// Gives back a representant item of the class.
     /// The representant is indpendent from the priorities of the
     /// items.
-    /// \return Gives back a representant item of the class.
     const Item& classRep(int id) const {
       int parent = classes[id].parent;

Context Navigation

Changeset 559:c5fd2d996909 in lemon-main

Legend:

doc/groups.dox

doc/mainpage.dox

lemon/adaptors.h

lemon/bin_heap.h

lemon/bits/edge_set_extender.h

lemon/circulation.h

lemon/concepts/graph.h

lemon/concepts/graph_components.h

lemon/concepts/heap.h

lemon/concepts/path.h

lemon/connectivity.h

lemon/core.h

lemon/dijkstra.h

lemon/edge_set.h

lemon/elevator.h

lemon/euler.h

lemon/graph_to_eps.h

lemon/grid_graph.h

lemon/hao_orlin.h

lemon/hypercube_graph.h

lemon/lgf_reader.h

lemon/lgf_writer.h

lemon/list_graph.h

lemon/maps.h

lemon/max_matching.h

lemon/min_cost_arborescence.h

lemon/path.h

lemon/preflow.h

lemon/radix_sort.h

lemon/random.h

lemon/smart_graph.h

lemon/suurballe.h

lemon/unionfind.h

Download in other formats: