Ticket #3013: graph.patch

boost/graph/clustering_coefficient.hpp

@@ -92 +92 @@
     Degree count(0);
     AdjacencyIterator i, j, end;
     for(tie(i, end) = adjacent_vertices(v, g); i != end; ++i) {
-        for(j = next(i); j != end; ++j) {
+        for(j = boost::next(i); j != end; ++j) {
             count += detail::count_edges(g, *i, *j, Directed());
         }
     }

boost/graph/detail/adjacency_list.hpp

@@ -791 +791 @@
             // of loop edges. This solution is based on the observation that
             // the incidence edges of a vertex with a loop are adjacent in the
             // out edge list. This *may* actually hold for multisets also.
-            bool skip = (next(i) != end && i->get_iter() == next(i)->get_iter());
+            bool skip = (boost::next(i) != end && i->get_iter() == boost::next(i)->get_iter());
             g.m_edges.erase((*i).get_iter());
             if (skip) ++i;
           }

boost/graph/eccentricity.hpp

@@ -86 +86 @@
     tie(i, end) = vertices(g);
     Eccentricity radius = get(ecc, *i);
     Eccentricity diameter = get(ecc, *i);
-    for(i = next(i); i != end; ++i) {
+    for(i = boost::next(i); i != end; ++i) {
         Eccentricity cur = get(ecc, *i);
         radius = min BOOST_PREVENT_MACRO_SUBSTITUTION (radius, cur);
         diameter = max BOOST_PREVENT_MACRO_SUBSTITUTION (diameter, cur);

boost/graph/is_straight_line_drawing.hpp

@@ -185 +185 @@
               before = active_edges.end();
             else
               before = prior(a_itr);
-            after = next(a_itr);
+            after = boost::next(a_itr);
 
             if (before != active_edges.end())
               {

boost/graph/isomorphism.hpp

@@ -237 +237 @@
                 num_edges_on_k = 1;
                 BOOST_USING_STD_MAX();
                 int next_k = max BOOST_PREVENT_MACRO_SUBSTITUTION(dfs_num_k, max BOOST_PREVENT_MACRO_SUBSTITUTION(dfs_num[i], dfs_num[j]));
-                if (match(next(iter), next_k))
+                if (match(boost::next(iter), next_k))
                   return true;
                 in_S[v] = false;
               }
@@ -247 +247 @@
           else {
             if (container_contains(adjacent_vertices(f[i], G2), f[j])) {
               ++num_edges_on_k;
-              if (match(next(iter), dfs_num_k))
+              if (match(boost::next(iter), dfs_num_k))
                 return true;
             }
                 

boost/graph/make_connected.hpp

@@ -62 +62 @@
     if (ci_prev == ci_end)
       return;
 
-    for(vec_of_vertices_itr_t ci = next(ci_prev); 
+    for(vec_of_vertices_itr_t ci = boost::next(ci_prev); 
         ci != ci_end;  ci_prev = ci, ++ci
         )
       {

boost/graph/make_maximal_planar.hpp

@@ -130 +130 @@
       // The iterator manipulations on the next two lines are safe because 
       // vertices_on_face.size() > 3 (from the first test in this function)
       fi_end = prior(vertices_on_face.end());
-      for(face_iterator fi = next(next(vertices_on_face.begin())); 
+          for(face_iterator fi = boost::next(boost::next(vertices_on_face.begin())); 
           fi != fi_end; ++fi
           )
         {
@@ -145 +145 @@
         {
           add_edge_range(
                          vertices_on_face[0],
-                         next(next(vertices_on_face.begin())),
+                         boost::next(boost::next(vertices_on_face.begin())),
                          prior(vertices_on_face.end())
                          );
         }
@@ -153 +153 @@
         {
           add_edge_range(
                          vertices_on_face[1],
-                         next(marked_neighbor),
+                         boost::next(marked_neighbor),
                          vertices_on_face.end()
                          );
 
           add_edge_range(
-                         *next(marked_neighbor),
-                         next(next(vertices_on_face.begin())),
+                         *boost::next(marked_neighbor),
+                         boost::next(boost::next(vertices_on_face.begin())),
                          marked_neighbor
                          );
         }

boost/graph/planar_canonical_ordering.hpp

@@ -101 +101 @@
           {
             
             edge_t e(*ei); // e = (u,v)
-            next_edge_itr = next(ei) == ei_end ? ei_start : next(ei);
+            next_edge_itr = boost::next(ei) == ei_end ? ei_start : boost::next(ei);
             vertex_t v = source(e,g) == u ? target(e,g) : source(e,g);
 
             vertex_t prior_vertex = source(*prior_edge_itr, g) == u ? 
@@ -127 +127 @@
             // past any loops or parallel edges
             while (next_vertex == v || next_vertex == u)
               {
-                next_edge_itr = next(next_edge_itr) == ei_end ?
-                  ei_start : next(next_edge_itr);
+                next_edge_itr = boost::next(next_edge_itr) == ei_end ?
+                  ei_start : boost::next(next_edge_itr);
                 next_vertex = source(*next_edge_itr, g) == u ? 
                   target(*next_edge_itr, g) : source(*next_edge_itr, g);
               }

boost/graph/planar_detail/boyer_myrvold_impl.hpp

@@ -1025 +1025 @@
       garbage.splice(garbage.end(), 
                      *separated_dfs_child_list[dfs_parent[v]], 
                      to_delete, 
-                     next(to_delete)
+                     boost::next(to_delete)
                      );
     }
 
@@ -1589 +1589 @@
                   if (w == graph_traits<Graph>::null_vertex() && 
                       externally_active(current_vertex,v) &&
                       outer_face_edge[e] &&
-                      outer_face_edge[*next(old_face_itr)] &&
+                      outer_face_edge[*boost::next(old_face_itr)] &&
                       !seen_x_or_y
                       )
                     {

boost/graph/planar_face_traversal.hpp

@@ -107 +107 @@
           {
             edge_t e(*pi);
             std::map<vertex_t, edge_t> m = get(next_edge, e);
-            m[v] = next(pi) == pi_end ? *pi_begin : *next(pi);
+            m[v] = boost::next(pi) == pi_end ? *pi_begin : *boost::next(pi);
             put(next_edge, e, m);
           } 
       }

libs/graph/test/tiernan_all_cycles.cpp

@@ -35 +35 @@
         // that the paths are valid.
         typename Path::const_iterator i, j, last = prior(p.end());
         for(i = p.begin(); i != last; ++i) {
-            j = next(i);
+            j = boost::next(i);
             BOOST_ASSERT(edge(*i, *j, g).second);
         }
         BOOST_ASSERT(edge(p.back(), p.front(), g).second);