vc++ workarounds and named parameter changes

[SVN r9959]

include/boost/graph/bandwidth.hpp

@@ -13,13 +13,13 @@ namespace boost {
 		VertexIndexMap index)
   {
     typedef typename graph_traits<Graph>::vertices_size_type size_type;
-    typedef typename detail::numeric_traits<size_type>::difference_type diff_t;
     size_type b = 0;
     typename graph_traits<Graph>::out_edge_iterator e, end;
     for (tie(e, end) = out_edges(i, g); e != end; ++e) {
-      diff_t f_i = get(index, i);
-      diff_t f_j = get(index, target(*e, g));
-      b = std::max(b, size_type(std::abs(f_i - f_j)));
+      int f_i = get(index, i);
+      int f_j = get(index, target(*e, g));
+      using namespace std;
+      b = std::max(b, size_type(abs(f_i - f_j)));
     }
     return b;
   }

include/boost/graph/breadth_first_search.hpp

@@ -239,12 +239,16 @@ namespace boost {
   // Named Parameter Variant
   template <class VertexListGraph, class P, class T, class R>
   void breadth_first_search
-    (VertexListGraph& g,
+    (const VertexListGraph& g,
      typename graph_traits<VertexListGraph>::vertex_descriptor s,
      const bgl_named_params<P, T, R>& params)
   {
+    // The graph is passed by *const* reference so that graph adaptors (temporaries)
+    // can be passed into this function. However, the graph is not really const
+    // since we may write to property maps of the graph.
+    VertexListGraph& ng = const_cast<VertexListGraph&>(g);
     typedef typename property_value< bgl_named_params<P,T,R>, vertex_color_t>::type C;
-    detail::bfs_dispatch<C>::apply(g, s, params, get_param(params, vertex_color));
+    detail::bfs_dispatch<C>::apply(ng, s, params, get_param(params, vertex_color));
   }
 
 

include/boost/graph/cuthill_mckee_ordering.hpp

@@ -133,7 +133,7 @@ namespace boost {
     typename boost::graph_traits<Graph>::vertex_iterator ui, ui_end;
     for (tie(ui, ui_end) = vertices(G); ui != ui_end; ++ui)
       put(color, *ui, Color::white());
-    breadth_first_search(G, u, Q, bfs_visitor<>(), color);
+    breadth_first_search(G, u, buffer(Q).color_map(color));
 
     ecc = Q.eccentricity(); 
     return Q.spouse();

include/boost/graph/edmunds_karp_max_flow.hpp

@@ -96,21 +96,21 @@ namespace boost {
        ColorMap color, 
        PredEdgeMap pred)
     {
+      typedef typename property_traits<ColorMap>::value_type ColorValue;
+      typedef color_traits<ColorValue> Color;
+
       typename graph_traits<Graph>::vertex_iterator u_iter, u_end;
       typename graph_traits<Graph>::out_edge_iterator ei, e_end;
       for (tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter)
 	for (tie(ei, e_end) = out_edges(*u_iter, g); ei != e_end; ++ei)
 	  res[*ei] = cap[*ei];
 
-      typedef color_traits<typename property_traits<ColorMap>::value_type> 
-	Color;
-
       color[sink] = Color::gray();
       while (color[sink] != Color::white()) {
 	breadth_first_search
 	  (detail::residual_graph(g, res), src,
-	   make_bfs_visitor(record_edge_predecessors(pred, on_tree_edge())),
-	   color);
+	   visitor(make_bfs_visitor(record_edge_predecessors(pred, on_tree_edge()))).
+	   color_map(color));
 	if (color[sink] != Color::white())
 	  detail::augment(g, src, sink, pred, res, rev);
       } // while
@@ -124,98 +124,111 @@ namespace boost {
     //-------------------------------------------------------------------------
     // Handle default for color property map
 
-    template <class Graph, class PredMap, class P, class T, class R>
-    typename edge_capacity_value<Graph, P, T, R>::type
-    edmunds_karp_dispatch2
-      (Graph& g,
-       typename graph_traits<Graph>::vertex_descriptor src,
-       typename graph_traits<Graph>::vertex_descriptor sink,
-       PredMap pred,
-       const bgl_named_params<P, T, R>& params,
-       detail::error_property_not_found)
-    {
-      typedef typename graph_traits<Graph>::edge_descriptor edge_descriptor;
-      typedef typename graph_traits<Graph>::vertices_size_type size_type;
-      size_type n = is_default_param(get_param(params, vertex_color)) ?
-	num_vertices(g) : 0;
-      std::vector<default_color_type> color_vec(n);
-      return edmunds_karp_max_flow_impl
-	(g, src, sink, 
-	 choose_const_pmap(get_param(params, edge_capacity), g, edge_capacity),
-	 choose_pmap(get_param(params, edge_residual_capacity), 
-		     g, edge_residual_capacity),
-	 choose_const_pmap(get_param(params, edge_reverse), g, edge_reverse),
-	 make_iterator_property_map(color_vec.begin(), choose_const_pmap
-				      (get_param(params, vertex_index),
-				       g, vertex_index), color_vec[0]),
-	 pred);
-    }
-
-    template <class Graph, class PredMap, class P, class T, class R, 
-              class ColorMap>
-    typename edge_capacity_value<Graph, P, T, R>::type
-    edmunds_karp_dispatch2
+    // use of class here is a VC++ workaround
+    template <class ColorMap>
+    struct edmunds_karp_dispatch2 {
+      template <class Graph, class PredMap, class P, class T, class R>
+      static typename edge_capacity_value<Graph, P, T, R>::type
+      apply
       (Graph& g,
        typename graph_traits<Graph>::vertex_descriptor src,
        typename graph_traits<Graph>::vertex_descriptor sink,
        PredMap pred,
        const bgl_named_params<P, T, R>& params,
        ColorMap color)
-    {
-      return edmunds_karp_max_flow_impl
-	(g, src, sink, 
-	 choose_const_pmap(get_param(params, edge_capacity), g, edge_capacity),
-	 choose_pmap(get_param(params, edge_residual_capacity), 
-		     g, edge_residual_capacity),
-	 choose_const_pmap(get_param(params, edge_reverse), g, edge_reverse),
-	 color, pred);
-    }
+      {
+	return edmunds_karp_max_flow_impl
+	  (g, src, sink, 
+	   choose_const_pmap(get_param(params, edge_capacity), g, edge_capacity),
+	   choose_pmap(get_param(params, edge_residual_capacity), 
+		       g, edge_residual_capacity),
+	   choose_const_pmap(get_param(params, edge_reverse), g, edge_reverse),
+	   color, pred);
+      }
+    };
+    template<>
+    struct edmunds_karp_dispatch2<detail::error_property_not_found> {
+      template <class Graph, class PredMap, class P, class T, class R>
+      static typename edge_capacity_value<Graph, P, T, R>::type
+      apply
+      (Graph& g,
+       typename graph_traits<Graph>::vertex_descriptor src,
+       typename graph_traits<Graph>::vertex_descriptor sink,
+       PredMap pred,
+       const bgl_named_params<P, T, R>& params,
+       detail::error_property_not_found)
+      {
+	typedef typename graph_traits<Graph>::edge_descriptor edge_descriptor;
+	typedef typename graph_traits<Graph>::vertices_size_type size_type;
+	size_type n = is_default_param(get_param(params, vertex_color)) ?
+	  num_vertices(g) : 0;
+	std::vector<default_color_type> color_vec(n);
+	return edmunds_karp_max_flow_impl
+	  (g, src, sink, 
+	   choose_const_pmap(get_param(params, edge_capacity), g, edge_capacity),
+	   choose_pmap(get_param(params, edge_residual_capacity), 
+		       g, edge_residual_capacity),
+	   choose_const_pmap(get_param(params, edge_reverse), g, edge_reverse),
+	   make_iterator_property_map(color_vec.begin(), choose_const_pmap
+				      (get_param(params, vertex_index),
+				       g, vertex_index), color_vec[0]),
+	   pred);
+      }
+    };
 
     //-------------------------------------------------------------------------
     // Handle default for predecessor property map
 
-    template <class Graph, class P, class T, class R>
-    typename edge_capacity_value<Graph, P, T, R>::type
-    edmunds_karp_dispatch1
+    // use of class here is a VC++ workaround
+    template <class PredMap>
+    struct edmunds_karp_dispatch1 {
+      template <class Graph, class P, class T, class R>
+      static typename edge_capacity_value<Graph, P, T, R>::type
+      apply(Graph& g,
+	    typename graph_traits<Graph>::vertex_descriptor src,
+	    typename graph_traits<Graph>::vertex_descriptor sink,
+	    const bgl_named_params<P, T, R>& params,
+	    PredMap pred)
+      {
+	typedef typename graph_traits<Graph>::edge_descriptor edge_descriptor;
+	typedef typename graph_traits<Graph>::vertices_size_type size_type;
+	size_type n = is_default_param(get_param(params, vertex_predecessor)) ?
+	  num_vertices(g) : 0;
+	std::vector<edge_descriptor> pred_vec(n);
+	
+	typedef typename property_value< bgl_named_params<P,T,R>, vertex_color_t>::type C;
+	return edmunds_karp_dispatch2<C>::apply
+	  (g, src, sink, pred, params, get_param(params, vertex_color));
+      }
+    };
+    template<>
+    struct edmunds_karp_dispatch1<detail::error_property_not_found> {
+
+      template <class Graph, class P, class T, class R>
+      static typename edge_capacity_value<Graph, P, T, R>::type
+      apply
       (Graph& g,
        typename graph_traits<Graph>::vertex_descriptor src,
        typename graph_traits<Graph>::vertex_descriptor sink,
        const bgl_named_params<P, T, R>& params,
        detail::error_property_not_found)
-    {
-      typedef typename graph_traits<Graph>::edge_descriptor edge_descriptor;
-      typedef typename graph_traits<Graph>::vertices_size_type size_type;
-      size_type n = is_default_param(get_param(params, vertex_predecessor)) ?
-	num_vertices(g) : 0;
-      std::vector<edge_descriptor> pred_vec(n);
-
-      return edmunds_karp_dispatch2
-	(g, src, sink, 
-	 make_iterator_property_map(pred_vec.begin(), choose_const_pmap
-				    (get_param(params, vertex_index),
-				     g, vertex_index), pred_vec[0]),
-	 params, 
-	 get_param(params, vertex_color));
-    }
-
-    template <class Graph, class P, class T, class R, class PredMap>
-    typename edge_capacity_value<Graph, P, T, R>::type
-    edmunds_karp_dispatch1
-      (Graph& g,
-       typename graph_traits<Graph>::vertex_descriptor src,
-       typename graph_traits<Graph>::vertex_descriptor sink,
-       const bgl_named_params<P, T, R>& params,
-       PredMap pred)
-    {
-      typedef typename graph_traits<Graph>::edge_descriptor edge_descriptor;
-      typedef typename graph_traits<Graph>::vertices_size_type size_type;
-      size_type n = is_default_param(get_param(params, vertex_predecessor)) ?
-	num_vertices(g) : 0;
-      std::vector<edge_descriptor> pred_vec(n);
-
-      return edmunds_karp_dispatch2
-	(g, src, sink, pred, params, get_param(params, vertex_color));
-    }
+      {
+	typedef typename graph_traits<Graph>::edge_descriptor edge_descriptor;
+	typedef typename graph_traits<Graph>::vertices_size_type size_type;
+	size_type n = is_default_param(get_param(params, vertex_predecessor)) ?
+	  num_vertices(g) : 0;
+	std::vector<edge_descriptor> pred_vec(n);
+	
+	typedef typename property_value< bgl_named_params<P,T,R>, vertex_color_t>::type C;
+	return edmunds_karp_dispatch2<C>::apply
+	  (g, src, sink, 
+	   make_iterator_property_map(pred_vec.begin(), choose_const_pmap
+				      (get_param(params, vertex_index),
+				       g, vertex_index), pred_vec[0]),
+	   params, 
+	   get_param(params, vertex_color));
+      }
+    };
     
   } // namespace detail
 
@@ -227,7 +240,8 @@ namespace boost {
      typename graph_traits<Graph>::vertex_descriptor sink,
      const bgl_named_params<P, T, R>& params)
   {
-    return detail::edmunds_karp_dispatch1
+    typedef typename property_value< bgl_named_params<P,T,R>, vertex_predecessor_t>::type Pred;
+    return detail::edmunds_karp_dispatch1<Pred>::apply
       (g, src, sink, params, get_param(params, vertex_predecessor));
   }
 

include/boost/graph/filtered_graph.hpp

@@ -372,9 +372,7 @@ namespace boost {
 
   template <typename G, typename EP, typename VP, typename Property,
             typename Key>
-  typename property_traits<
-    typename property_map<G, Property>::const_type
-  >::value_type
+  typename property_map_value<G, Property>::type
   get(Property p, const filtered_graph<G, EP, VP>& g, const Key& k)
   {
     return get(p, (const G&)g.m_g, k);

include/boost/graph/named_function_params.hpp

@@ -384,7 +384,7 @@ namespace boost {
 
   template <typename Buffer>
   bgl_named_params<detail::wrap_ref<Buffer>, buffer_param_t>
-  buffer(const Buffer& b) {
+  buffer(Buffer& b) {
     typedef bgl_named_params<detail::wrap_ref<Buffer>, buffer_param_t> Params;
     return Params(detail::wrap_ref<Buffer>(b));
   }

include/boost/graph/properties.hpp

@@ -228,6 +228,14 @@ namespace boost {
     typedef typename Map::const_type const_type;
   };
 
+  // shortcut for accessing the value type of the property map
+  template <class Graph, class Property>
+  class property_map_value {
+    typedef typename property_map<Graph, Property>::const_type PMap;
+  public:
+    typedef typename property_traits<PMap>::value_type type;
+  };
+
   template <class Graph, class Property>
   class graph_property {
   public: