subgraph related changes

[SVN r12107]

include/boost/graph/detail/adjacency_list.hpp

@@ -354,8 +354,8 @@ namespace boost {
       remove_directed_edge_dispatch(edge_descriptor, EdgeList& el,
                                     StoredProperty& p)
       {
-        typename EdgeList::iterator i = el.begin();
-        for (; i != el.end(); ++i)
+        for (typename EdgeList::iterator i = el.begin();
+             i != el.end(); ++i)
           if (&(*i).get_property() == &p) {
             el.erase(i);
             return;
@@ -368,8 +368,8 @@ namespace boost {
       remove_directed_edge_dispatch(edge_descriptor e, EdgeList& el,
                                     no_property&)
       {
-        typename EdgeList::iterator i = el.begin();
-        for (; i != el.end(); ++i)
+        for (typename EdgeList::iterator i = el.begin();
+             i != el.end(); ++i)
           if ((*i).get_target() == e.m_target) {
             el.erase(i);
             return;

include/boost/graph/graph_test.hpp

@@ -80,23 +80,25 @@ namespace boost {
 
     void test_bidirectional_graph
       (const std::vector<vertex_t>& vertex_set,
-       const std::vector<edge_t>& edge_set,
+       const std::vector< std::pair<vertex_t, vertex_t> >& edge_set,
        const Graph& g)
     {
       typedef typename std::vector<vertex_t>::const_iterator vertex_iter;
-      typedef typename std::vector<edge_t>::const_iterator edge_iter;
+      typedef typename std::vector< std::pair<vertex_t, vertex_t> >
+        ::const_iterator edge_iter;
       typedef typename graph_traits<Graph>::in_edge_iterator in_edge_iter;
 
       for (vertex_iter vi = vertex_set.begin(); vi != vertex_set.end(); ++vi) {
 	vertex_t v = *vi;
 	std::vector<vertex_t> inv_adj;
 	for (edge_iter e = edge_set.begin(); e != edge_set.end(); ++e)
-	  if (target(*e, g) == v)
-	    inv_adj.push_back(source(*e, g));
+	  if (e->second == v)
+	    inv_adj.push_back(e->first);
 
 	std::pair<in_edge_iter, in_edge_iter> p = in_edges(v, g);
 	BOOST_TEST(in_degree(v, g) == inv_adj.size());
-	BOOST_TEST(std::distance(p.first, p.second) == in_degree(v, g));
+	BOOST_TEST(deg_size_t(std::distance(p.first, p.second))
+                   == in_degree(v, g));
 	for (; p.first != p.second; ++p.first) {
 	  edge_t e = *p.first;
 	  BOOST_TEST(target(e, g) == v);
@@ -167,23 +169,25 @@ namespace boost {
 
     void test_adjacency_matrix
       (const std::vector<vertex_t>& vertex_set, 
-       const std::vector<edge_t>& edge_set, 
+       const std::vector< std::pair<vertex_t, vertex_t> >& edge_set, 
        const Graph& g)
     {
       std::pair<edge_t, bool> p;
-      for (typename std::vector<edge_t>::const_iterator i = edge_set.begin();
+      for (typename std::vector<std::pair<vertex_t, vertex_t> >
+             ::const_iterator i = edge_set.begin();
 	   i != edge_set.end(); ++i) {
-	p = edge(source(*i, g), target(*i, g), g);
+	p = edge(i->first, i->second, g);
 	BOOST_TEST(p.second == true);
-	BOOST_TEST(source(p.first, g) == source(*i, g));
-	BOOST_TEST(target(p.first, g) == target(*i, g));
+	BOOST_TEST(source(p.first, g) == i->first);
+	BOOST_TEST(target(p.first, g) == i->second);
       }
       typename std::vector<vertex_t>::const_iterator j, k;
       for (j = vertex_set.begin(); j != vertex_set.end(); ++j)
 	for (k = vertex_set.begin(); k != vertex_set.end(); ++k) {
 	  p = edge(*j, *k, g);
 	  if (p.second == true)
-	    BOOST_TEST(contains(edge_set, p.first) == true);
+	    BOOST_TEST(any_if(edge_set, 
+              connects(source(p.first, g), target(p.first, g), g)) == true);
 	}
     }
     

include/boost/graph/graph_utility.hpp

@@ -302,6 +302,38 @@ namespace boost {
     }
   }
 
+  template <typename MutableGraph, typename RandNumGen,
+            typename VertexOutputIterator, typename EdgeOutputIterator>
+  void generate_random_graph
+    (MutableGraph& g, 
+     typename graph_traits<MutableGraph>::vertices_size_type V,
+     typename graph_traits<MutableGraph>::vertices_size_type E,
+     RandNumGen& gen,
+     VertexOutputIterator vertex_out,
+     EdgeOutputIterator edge_out,
+     bool self_edges = false)
+  {
+    typedef graph_traits<MutableGraph> Traits;
+    typedef typename Traits::vertices_size_type v_size_t;
+    typedef typename Traits::edges_size_type e_size_t;
+    typedef typename Traits::vertex_descriptor vertex_t;
+    typedef typename Traits::edge_descriptor edge_t;
+
+    for (v_size_t i = 0; i < V; ++i)
+      *vertex_out++ = add_vertex(g);
+
+    for (e_size_t j = 0; j < E; ++j) {
+      vertex_t a = random_vertex(g, gen), b;
+      do {
+        b = random_vertex(g, gen);
+      } while (self_edges == false && a == b);
+      edge_t e; bool inserted;
+      tie(e, inserted) = add_edge(a, b, g);
+      if (inserted)
+	*edge_out++ = std::make_pair(source(e, g), target(e, g));
+    }
+  }
+
   template <class Graph, class Vertex>
   bool is_adj_dispatch(Graph& g, Vertex a, Vertex b, bidirectional_tag)
   {

include/boost/graph/subgraph.hpp

@@ -57,6 +57,7 @@ namespace boost {
   template <typename Graph>
   class subgraph {
     typedef graph_traits<Graph> Traits;
+    typedef std::list<subgraph<Graph>*> ChildrenList;
   public:
     // Graph requirements
     typedef typename Traits::vertex_descriptor         vertex_descriptor;
@@ -114,14 +115,14 @@ namespace boost {
       m_global_vertex(x.m_global_vertex)
     {
       // Do a deep copy
-      for (std::list< subgraph<Graph>*>::iterator i = x.m_children.begin();
+      for (typename ChildrenList::const_iterator i = x.m_children.begin();
 	   i != x.m_children.end(); ++i)
 	m_children.push_back(new subgraph<Graph>( **i ));
     }
 
 
     ~subgraph() {
-      for (std::list< subgraph<Graph>*>::iterator i = m_children.begin();
+      for (typename ChildrenList::iterator i = m_children.begin();
 	   i != m_children.end(); ++i)
 	delete *i;
     }
@@ -201,7 +202,6 @@ namespace boost {
     // Return the children subgraphs of this graph/subgraph.
     // Use a list of pointers because the VC++ std::list doesn't like
     // storing incomplete type.
-    typedef std::list< subgraph<Graph>*> ChildrenList;
     typedef typename indirect_iterator_generator<typename ChildrenList::iterator,
       subgraph<Graph>, subgraph<Graph>&, std::bidirectional_iterator_tag, 
       subgraph<Graph>* >::type children_iterator;
@@ -227,18 +227,17 @@ namespace boost {
     std::size_t num_children() const { return m_children.size(); }
 
     //  private:
-    Graph m_graph;
-    subgraph<Graph>* m_parent;
-    ChildrenList m_children;
-    std::vector<vertex_descriptor> m_global_vertex; // local -> global
-    std::map<vertex_descriptor, vertex_descriptor> m_local_vertex;  // global -> local
-
     typedef typename property_map<Graph, edge_index_t>::type EdgeIndexMap;
     typedef typename property_traits<EdgeIndexMap>::value_type edge_index_type;
 
+    Graph m_graph;
+    subgraph<Graph>* m_parent;
+    edge_index_type m_edge_counter; // for generating unique edge indices
+    ChildrenList m_children;
+    std::vector<vertex_descriptor> m_global_vertex; // local -> global
+    std::map<vertex_descriptor, vertex_descriptor> m_local_vertex;  // global -> local
     std::vector<edge_descriptor> m_global_edge;              // local -> global
     std::map<edge_index_type, edge_descriptor> m_local_edge; // global -> local
-    edge_index_type m_edge_counter; // for generating unique edge indices
 
     edge_descriptor
     local_add_edge(vertex_descriptor u_local, vertex_descriptor v_local,