# HG changeset patch
# User deba
# Date 1196414558 0
# Node ID 93de38566e6c12ba01e313149b750c146dba20ac
# Parent  e6bc5c0032e970d950d3d17effdb178fb5362264
Minor changes

diff -r e6bc5c0032e9 -r 93de38566e6c lemon/bin_heap.h
--- a/lemon/bin_heap.h	Wed Nov 28 18:05:49 2007 +0000
+++ b/lemon/bin_heap.h	Fri Nov 30 09:22:38 2007 +0000
@@ -29,10 +29,10 @@
 
 namespace lemon {
 
-  /// \ingroup auxdat
-
-  /// A Binary Heap implementation.
-  
+  ///\ingroup auxdat
+  ///
+  ///\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
@@ -229,7 +229,7 @@
     }
 
     /// \brief Decreases the priority of \c i to \c p.
-
+    ///
     /// This method decreases the priority of item \c i to \c p.
     /// \pre \c i must be stored in the heap with priority at least \c
     /// p relative to \c Compare.
diff -r e6bc5c0032e9 -r 93de38566e6c lemon/fib_heap.h
--- a/lemon/fib_heap.h	Wed Nov 28 18:05:49 2007 +0000
+++ b/lemon/fib_heap.h	Fri Nov 30 09:22:38 2007 +0000
@@ -30,9 +30,9 @@
 namespace lemon {
   
   /// \ingroup auxdat
-
-  /// Fibonacci Heap.
-
+  ///
+  ///\brief Fibonacci Heap.
+  ///
   ///This class implements the \e Fibonacci \e heap data structure. A \e heap
   ///is a data structure for storing items with specified values called \e
   ///priorities in such a way that finding the item with minimum priority is
diff -r e6bc5c0032e9 -r 93de38566e6c lemon/graph_adaptor.h
--- a/lemon/graph_adaptor.h	Wed Nov 28 18:05:49 2007 +0000
+++ b/lemon/graph_adaptor.h	Fri Nov 30 09:22:38 2007 +0000
@@ -34,7 +34,6 @@
 #include <lemon/bits/base_extender.h>
 #include <lemon/bits/graph_adaptor_extender.h>
 #include <lemon/bits/graph_extender.h>
-
 #include <lemon/tolerance.h>
 
 #include <algorithm>
@@ -947,8 +946,8 @@
   ///ConstMap<Edge, int> const_1_map(1);
   ///Graph::EdgeMap<int> flow(g, 0);
   ///
-  ///Preflow<SubGA, int, ConstMap<Edge, int>, Graph::EdgeMap<int> > 
-  ///  preflow(ga, s, t, const_1_map, flow);
+  ///Preflow<SubGA, ConstMap<Edge, int>, Graph::EdgeMap<int> > 
+  ///  preflow(ga, const_1_map, s, t);
   ///preflow.run();
   ///\endcode
   ///Last, the output is:
@@ -958,7 +957,7 @@
   ///cout << "edges of the maximum number of edge-disjoint shortest s-t paths: " 
   ///     << endl;
   ///for(EdgeIt e(g); e!=INVALID; ++e) 
-  ///  if (flow[e])
+  ///  if (preflow.flow(e))
   ///    cout << " " << g.id(g.source(e)) << "--"
   ///         << length[e] << "->" << g.id(g.target(e)) << endl;
   ///\endcode
@@ -2021,6 +2020,7 @@
       }
       return INVALID;
     }
+
     
     template <typename T>
     class NodeMap : public MapBase<Node, T> {
@@ -2030,7 +2030,15 @@
 	: inNodeMap(_graph), outNodeMap(_graph) {}
       NodeMap(const SplitGraphAdaptorBase& _graph, const T& t) 
 	: inNodeMap(_graph, t), outNodeMap(_graph, t) {}
-      
+      NodeMap& operator=(const NodeMap& cmap) {
+        return operator=<NodeMap>(cmap);
+      }
+      template <typename CMap>
+      NodeMap& operator=(const CMap& cmap) {
+        Parent::operator=(cmap);
+        return *this;
+      }
+
       void set(const Node& key, const T& val) {
 	if (SplitGraphAdaptorBase::inNode(key)) { inNodeMap.set(key, val); }
 	else {outNodeMap.set(key, val); }
@@ -2062,6 +2070,14 @@
 	: edge_map(_graph), node_map(_graph) {}
       EdgeMap(const SplitGraphAdaptorBase& _graph, const T& t) 
 	: edge_map(_graph, t), node_map(_graph, t) {}
+      EdgeMap& operator=(const EdgeMap& cmap) {
+        return operator=<EdgeMap>(cmap);
+      }
+      template <typename CMap>
+      EdgeMap& operator=(const CMap& cmap) {
+        Parent::operator=(cmap);
+        return *this;
+      }
       
       void set(const Edge& key, const T& val) {
 	if (SplitGraphAdaptorBase::origEdge(key)) { 
@@ -2470,9 +2486,9 @@
   ///
   /// SGraph::EdgeMap<int> sflow(sgraph);
   ///
-  /// Preflow<SGraph, int, SCapacity> 
-  ///   spreflow(sgraph, SGraph::outNode(source),SGraph::inNode(target),  
-  ///            scapacity, sflow);
+  /// Preflow<SGraph, SCapacity> 
+  ///   spreflow(sgraph, scapacity, 
+  ///            SGraph::outNode(source), SGraph::inNode(target));
   ///                                            
   /// spreflow.run();
   ///
diff -r e6bc5c0032e9 -r 93de38566e6c lemon/min_mean_cycle.h
--- a/lemon/min_mean_cycle.h	Wed Nov 28 18:05:49 2007 +0000
+++ b/lemon/min_mean_cycle.h	Fri Nov 30 09:22:38 2007 +0000
@@ -19,7 +19,7 @@
 #ifndef LEMON_MIN_MEAN_CYCLE_H
 #define LEMON_MIN_MEAN_CYCLE_H
 
-/// \ingroup min_cost_flow
+/// \ingroup shortest_path
 ///
 /// \file
 /// \brief Karp's algorithm for finding a minimum mean (directed) cycle.
@@ -31,7 +31,7 @@
 
 namespace lemon {
 
-  /// \addtogroup min_cost_flow
+  /// \addtogroup shortest_path
   /// @{
 
   /// \brief Implementation of Karp's algorithm for finding a
diff -r e6bc5c0032e9 -r 93de38566e6c lemon/topology.h
--- a/lemon/topology.h	Wed Nov 28 18:05:49 2007 +0000
+++ b/lemon/topology.h	Fri Nov 30 09:22:38 2007 +0000
@@ -715,7 +715,6 @@
   ///
   /// \param graph The graph.
   /// \return %True when the graph bi-node-connected.
-  /// \todo Make it faster.
   template <typename UGraph>
   bool biNodeConnected(const UGraph& graph) {
     return countBiNodeConnectedComponents(graph) == 1;
@@ -1042,7 +1041,6 @@
   ///
   /// \param graph The undirected graph.
   /// \return The number of components.
-  /// \todo Make it faster.
   template <typename UGraph>
   bool biEdgeConnected(const UGraph& graph) { 
     return countBiEdgeConnectedComponents(graph) == 1;
diff -r e6bc5c0032e9 -r 93de38566e6c test/graph_adaptor_test.cc
--- a/test/graph_adaptor_test.cc	Wed Nov 28 18:05:49 2007 +0000
+++ b/test/graph_adaptor_test.cc	Fri Nov 30 09:22:38 2007 +0000
@@ -66,6 +66,8 @@
     checkConcept<Graph, ErasingFirstGraphAdaptor<Graph, 
       Graph::NodeMap<Graph::Edge> > >(); 
 
+    checkConcept<Graph, SplitGraphAdaptor<Graph> >(); 
+
     checkConcept<UGraph, UndirGraphAdaptor<Graph> >();
 
     checkConcept<UGraph, SubUGraphAdaptor<UGraph,