You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1084 lines
38 KiB
1084 lines
38 KiB
//======================================================================= |
|
// Copyright 2001 University of Notre Dame. |
|
// Authors: Jeremy G. Siek and Lie-Quan Lee |
|
// |
|
// Distributed under the Boost Software License, Version 1.0. (See |
|
// accompanying file LICENSE_1_0.txt or copy at |
|
// http://www.boost.org/LICENSE_1_0.txt) |
|
//======================================================================= |
|
|
|
#ifndef BOOST_SUBGRAPH_HPP |
|
#define BOOST_SUBGRAPH_HPP |
|
|
|
// UNDER CONSTRUCTION |
|
|
|
#include <boost/config.hpp> |
|
#include <list> |
|
#include <vector> |
|
#include <map> |
|
#include <boost/assert.hpp> |
|
#include <boost/graph/graph_traits.hpp> |
|
#include <boost/graph/graph_mutability_traits.hpp> |
|
#include <boost/graph/properties.hpp> |
|
#include <boost/iterator/indirect_iterator.hpp> |
|
|
|
#include <boost/static_assert.hpp> |
|
#include <boost/assert.hpp> |
|
#include <boost/type_traits.hpp> |
|
#include <boost/mpl/if.hpp> |
|
#include <boost/mpl/or.hpp> |
|
|
|
namespace boost { |
|
|
|
struct subgraph_tag { }; |
|
|
|
/** @name Property Lookup |
|
* The local_property and global_property functions are used to create |
|
* structures that determine the lookup strategy for properties in subgraphs. |
|
* Note that the nested kind member is used to help interoperate with actual |
|
* Property types. |
|
*/ |
|
//@{ |
|
template <typename T> |
|
struct local_property |
|
{ |
|
typedef T kind; |
|
local_property(T x) : value(x) { } |
|
T value; |
|
}; |
|
|
|
template <typename T> |
|
inline local_property<T> local(T x) |
|
{ return local_property<T>(x); } |
|
|
|
template <typename T> |
|
struct global_property |
|
{ |
|
typedef T kind; |
|
global_property(T x) : value(x) { } |
|
T value; |
|
}; |
|
|
|
template <typename T> |
|
inline global_property<T> global(T x) |
|
{ return global_property<T>(x); } |
|
//@} |
|
|
|
// Invariants of an induced subgraph: |
|
// - If vertex u is in subgraph g, then u must be in g.parent(). |
|
// - If edge e is in subgraph g, then e must be in g.parent(). |
|
// - If edge e=(u,v) is in the root graph, then edge e |
|
// is also in any subgraph that contains both vertex u and v. |
|
|
|
// The Graph template parameter must have a vertex_index and edge_index |
|
// internal property. It is assumed that the vertex indices are assigned |
|
// automatically by the graph during a call to add_vertex(). It is not |
|
// assumed that the edge vertices are assigned automatically, they are |
|
// explicitly assigned here. |
|
|
|
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; |
|
typedef typename Traits::edge_descriptor edge_descriptor; |
|
typedef typename Traits::directed_category directed_category; |
|
typedef typename Traits::edge_parallel_category edge_parallel_category; |
|
typedef typename Traits::traversal_category traversal_category; |
|
|
|
// IncidenceGraph requirements |
|
typedef typename Traits::out_edge_iterator out_edge_iterator; |
|
typedef typename Traits::degree_size_type degree_size_type; |
|
|
|
// AdjacencyGraph requirements |
|
typedef typename Traits::adjacency_iterator adjacency_iterator; |
|
|
|
// VertexListGraph requirements |
|
typedef typename Traits::vertex_iterator vertex_iterator; |
|
typedef typename Traits::vertices_size_type vertices_size_type; |
|
|
|
// EdgeListGraph requirements |
|
typedef typename Traits::edge_iterator edge_iterator; |
|
typedef typename Traits::edges_size_type edges_size_type; |
|
|
|
typedef typename Traits::in_edge_iterator in_edge_iterator; |
|
|
|
typedef typename edge_property_type<Graph>::type edge_property_type; |
|
typedef typename vertex_property_type<Graph>::type vertex_property_type; |
|
typedef subgraph_tag graph_tag; |
|
typedef Graph graph_type; |
|
typedef typename graph_property_type<Graph>::type graph_property_type; |
|
|
|
// Create the main graph, the root of the subgraph tree |
|
subgraph() |
|
: m_parent(0), m_edge_counter(0) |
|
{ } |
|
|
|
subgraph(const graph_property_type& p) |
|
: m_graph(p), m_parent(0), m_edge_counter(0) |
|
{ } |
|
|
|
subgraph(vertices_size_type n, const graph_property_type& p = graph_property_type()) |
|
: m_graph(n, p), m_parent(0), m_edge_counter(0), m_global_vertex(n) |
|
{ |
|
typename Graph::vertex_iterator v, v_end; |
|
vertices_size_type i = 0; |
|
for(boost::tie(v, v_end) = vertices(m_graph); v != v_end; ++v) |
|
m_global_vertex[i++] = *v; |
|
} |
|
|
|
// copy constructor |
|
subgraph(const subgraph& x) |
|
: m_parent(x.m_parent), m_edge_counter(0) |
|
{ |
|
if(x.is_root()) |
|
{ |
|
m_graph = x.m_graph; |
|
m_edge_counter = x.m_edge_counter; |
|
m_global_vertex = x.m_global_vertex; |
|
m_global_edge = x.m_global_edge; |
|
} |
|
else |
|
{ |
|
get_property(*this) = get_property(x); |
|
typename subgraph<Graph>::vertex_iterator vi,vi_end; |
|
boost::tie(vi, vi_end) = vertices(x); |
|
for(; vi != vi_end; ++vi) |
|
{ |
|
add_vertex(x.local_to_global(*vi), *this); |
|
} |
|
} |
|
// Do a deep copy (recursive). |
|
// Only the root graph is copied, the subgraphs contain |
|
// only references to the global vertices they own. |
|
typename subgraph<Graph>::children_iterator i,i_end; |
|
boost::tie(i,i_end) = x.children(); |
|
for(; i != i_end; ++i) |
|
{ |
|
m_children.push_back(new subgraph<Graph>(*i)); |
|
m_children.back()->m_parent = this; |
|
} |
|
} |
|
|
|
|
|
~subgraph() { |
|
for(typename ChildrenList::iterator i = m_children.begin(); |
|
i != m_children.end(); ++i) |
|
{ |
|
delete *i; |
|
} |
|
} |
|
|
|
// Return a null vertex descriptor for the graph. |
|
static vertex_descriptor null_vertex() |
|
{ return Traits::null_vertex(); } |
|
|
|
|
|
// Create a subgraph |
|
subgraph<Graph>& create_subgraph() { |
|
m_children.push_back(new subgraph<Graph>()); |
|
m_children.back()->m_parent = this; |
|
return *m_children.back(); |
|
} |
|
|
|
// Create a subgraph with the specified vertex set. |
|
template <typename VertexIterator> |
|
subgraph<Graph>& create_subgraph(VertexIterator first, VertexIterator last) { |
|
m_children.push_back(new subgraph<Graph>()); |
|
m_children.back()->m_parent = this; |
|
for(; first != last; ++first) { |
|
add_vertex(*first, *m_children.back()); |
|
} |
|
return *m_children.back(); |
|
} |
|
|
|
// local <-> global descriptor conversion functions |
|
vertex_descriptor local_to_global(vertex_descriptor u_local) const |
|
{ return is_root() ? u_local : m_global_vertex[u_local]; } |
|
|
|
vertex_descriptor global_to_local(vertex_descriptor u_global) const { |
|
vertex_descriptor u_local; bool in_subgraph; |
|
if (is_root()) return u_global; |
|
boost::tie(u_local, in_subgraph) = this->find_vertex(u_global); |
|
BOOST_ASSERT(in_subgraph == true); |
|
return u_local; |
|
} |
|
|
|
edge_descriptor local_to_global(edge_descriptor e_local) const |
|
{ return is_root() ? e_local : m_global_edge[get(get(edge_index, m_graph), e_local)]; } |
|
|
|
edge_descriptor global_to_local(edge_descriptor e_global) const |
|
{ return is_root() ? e_global : (*m_local_edge.find(get(get(edge_index, root().m_graph), e_global))).second; } |
|
|
|
// Is vertex u (of the root graph) contained in this subgraph? |
|
// If so, return the matching local vertex. |
|
std::pair<vertex_descriptor, bool> |
|
find_vertex(vertex_descriptor u_global) const { |
|
if (is_root()) return std::make_pair(u_global, true); |
|
typename LocalVertexMap::const_iterator i = m_local_vertex.find(u_global); |
|
bool valid = i != m_local_vertex.end(); |
|
return std::make_pair((valid ? (*i).second : null_vertex()), valid); |
|
} |
|
|
|
// Is edge e (of the root graph) contained in this subgraph? |
|
// If so, return the matching local edge. |
|
std::pair<edge_descriptor, bool> |
|
find_edge(edge_descriptor e_global) const { |
|
if (is_root()) return std::make_pair(e_global, true); |
|
typename LocalEdgeMap::const_iterator i = |
|
m_local_edge.find(get(get(edge_index, root().m_graph), e_global)); |
|
bool valid = i != m_local_edge.end(); |
|
return std::make_pair((valid ? (*i).second : edge_descriptor()), valid); |
|
} |
|
|
|
// Return the parent graph. |
|
subgraph& parent() { return *m_parent; } |
|
const subgraph& parent() const { return *m_parent; } |
|
|
|
// Return true if this is the root subgraph |
|
bool is_root() const { return m_parent == 0; } |
|
|
|
// Return the root graph of the subgraph tree. |
|
subgraph& root() |
|
{ return is_root() ? *this : m_parent->root(); } |
|
|
|
const subgraph& root() const |
|
{ return is_root() ? *this : m_parent->root(); } |
|
|
|
// 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 indirect_iterator< |
|
typename ChildrenList::const_iterator |
|
, subgraph<Graph> |
|
, std::bidirectional_iterator_tag |
|
> |
|
children_iterator; |
|
|
|
typedef indirect_iterator< |
|
typename ChildrenList::const_iterator |
|
, subgraph<Graph> const |
|
, std::bidirectional_iterator_tag |
|
> |
|
const_children_iterator; |
|
|
|
std::pair<const_children_iterator, const_children_iterator> children() const { |
|
return std::make_pair(const_children_iterator(m_children.begin()), |
|
const_children_iterator(m_children.end())); |
|
} |
|
|
|
std::pair<children_iterator, children_iterator> children() { |
|
return std::make_pair(children_iterator(m_children.begin()), |
|
children_iterator(m_children.end())); |
|
} |
|
|
|
std::size_t num_children() const { return m_children.size(); } |
|
|
|
#ifndef BOOST_GRAPH_NO_BUNDLED_PROPERTIES |
|
// Defualt property access delegates the lookup to global properties. |
|
template <typename Descriptor> |
|
typename graph::detail::bundled_result<Graph, Descriptor>::type& |
|
operator[](Descriptor x) |
|
{ return is_root() ? m_graph[x] : root().m_graph[local_to_global(x)]; } |
|
|
|
template <typename Descriptor> |
|
typename graph::detail::bundled_result<Graph, Descriptor>::type const& |
|
operator[](Descriptor x) const |
|
{ return is_root() ? m_graph[x] : root().m_graph[local_to_global(x)]; } |
|
|
|
// Local property access returns the local property of the given descripor. |
|
template <typename Descriptor> |
|
typename graph::detail::bundled_result<Graph, Descriptor>::type& |
|
operator[](local_property<Descriptor> x) |
|
{ return m_graph[x.value]; } |
|
|
|
template <typename Descriptor> |
|
typename graph::detail::bundled_result<Graph, Descriptor>::type const& |
|
operator[](local_property<Descriptor> x) const |
|
{ return m_graph[x.value]; } |
|
|
|
// Global property access returns the global property associated with the |
|
// given descriptor. This is an alias for the default bundled property |
|
// access operations. |
|
template <typename Descriptor> |
|
typename graph::detail::bundled_result<Graph, Descriptor>::type& |
|
operator[](global_property<Descriptor> x) |
|
{ return (*this)[x.value]; } |
|
|
|
template <typename Descriptor> |
|
typename graph::detail::bundled_result<Graph, Descriptor>::type const& |
|
operator[](global_property<Descriptor> x) const |
|
{ return (*this)[x.value]; } |
|
|
|
#endif // BOOST_GRAPH_NO_BUNDLED_PROPERTIES |
|
|
|
// private: |
|
typedef typename property_map<Graph, edge_index_t>::type EdgeIndexMap; |
|
typedef typename property_traits<EdgeIndexMap>::value_type edge_index_type; |
|
BOOST_STATIC_ASSERT((!is_same<edge_index_type, |
|
boost::detail::error_property_not_found>::value)); |
|
|
|
private: |
|
typedef std::vector<vertex_descriptor> GlobalVertexList; |
|
typedef std::vector<edge_descriptor> GlobalEdgeList; |
|
typedef std::map<vertex_descriptor, vertex_descriptor> LocalVertexMap; |
|
typedef std::map<edge_index_type, edge_descriptor> LocalEdgeMap; |
|
// TODO: Should the LocalVertexMap be: map<index_type, descriptor>? |
|
// TODO: Can we relax the indexing requirement if both descriptors are |
|
// LessThanComparable? |
|
// TODO: Should we really be using unorderd_map for improved lookup times? |
|
|
|
public: // Probably shouldn't be public.... |
|
Graph m_graph; |
|
subgraph<Graph>* m_parent; |
|
edge_index_type m_edge_counter; // for generating unique edge indices |
|
ChildrenList m_children; |
|
GlobalVertexList m_global_vertex; // local -> global |
|
LocalVertexMap m_local_vertex; // global -> local |
|
GlobalEdgeList m_global_edge; // local -> global |
|
LocalEdgeMap m_local_edge; // global -> local |
|
|
|
edge_descriptor local_add_edge(vertex_descriptor u_local, |
|
vertex_descriptor v_local, |
|
edge_descriptor e_global) |
|
{ |
|
edge_descriptor e_local; |
|
bool inserted; |
|
boost::tie(e_local, inserted) = add_edge(u_local, v_local, m_graph); |
|
put(edge_index, m_graph, e_local, m_edge_counter++); |
|
m_global_edge.push_back(e_global); |
|
m_local_edge[get(get(edge_index, this->root()), e_global)] = e_local; |
|
return e_local; |
|
} |
|
}; |
|
|
|
template <typename Graph> |
|
struct vertex_bundle_type<subgraph<Graph> > |
|
: vertex_bundle_type<Graph> |
|
{ }; |
|
|
|
template<typename Graph> |
|
struct edge_bundle_type<subgraph<Graph> > |
|
: edge_bundle_type<Graph> |
|
{ }; |
|
|
|
template<typename Graph> |
|
struct graph_bundle_type<subgraph<Graph> > |
|
: graph_bundle_type<Graph> |
|
{ }; |
|
|
|
//=========================================================================== |
|
// Functions special to the Subgraph Class |
|
|
|
template <typename G> |
|
typename subgraph<G>::vertex_descriptor |
|
add_vertex(typename subgraph<G>::vertex_descriptor u_global, |
|
subgraph<G>& g) |
|
{ |
|
BOOST_ASSERT(!g.is_root()); |
|
typename subgraph<G>::vertex_descriptor u_local; |
|
bool exists_local; |
|
boost::tie(u_local, exists_local) = g.find_vertex(u_global); |
|
|
|
if (!exists_local) { |
|
typename subgraph<G>::vertex_descriptor v_global; |
|
typename subgraph<G>::edge_descriptor e_global; |
|
// call recursion for parent subgraph |
|
if (!g.parent().is_root()) |
|
add_vertex(u_global, g.parent()); |
|
|
|
u_local = add_vertex(g.m_graph); |
|
g.m_global_vertex.push_back(u_global); |
|
g.m_local_vertex[u_global] = u_local; |
|
|
|
subgraph<G>& r = g.root(); |
|
|
|
// remember edge global and local maps |
|
{ |
|
typename subgraph<G>::out_edge_iterator ei, ei_end; |
|
for (boost::tie(ei, ei_end) = out_edges(u_global, r); |
|
ei != ei_end; ++ei) { |
|
e_global = *ei; |
|
v_global = target(e_global, r); |
|
if (g.find_vertex(v_global).second == true) |
|
g.local_add_edge(u_local, g.global_to_local(v_global), e_global); |
|
} |
|
} |
|
if (is_directed(g)) { // not necessary for undirected graph |
|
typename subgraph<G>::vertex_iterator vi, vi_end; |
|
typename subgraph<G>::out_edge_iterator ei, ei_end; |
|
for(boost::tie(vi, vi_end) = vertices(r); vi != vi_end; ++vi) { |
|
v_global = *vi; |
|
if (v_global == u_global) |
|
continue; // don't insert self loops twice! |
|
if (!g.find_vertex(v_global).second) |
|
continue; // not a subgraph vertex => try next one |
|
for(boost::tie(ei, ei_end) = out_edges(*vi, r); ei != ei_end; ++ei) { |
|
e_global = *ei; |
|
if(target(e_global, r) == u_global) { |
|
g.local_add_edge(g.global_to_local(v_global), u_local, e_global); |
|
} |
|
} |
|
} |
|
} |
|
} |
|
return u_local; |
|
} |
|
|
|
// NOTE: Descriptors are local unless otherwise noted. |
|
|
|
//=========================================================================== |
|
// Functions required by the IncidenceGraph concept |
|
|
|
template <typename G> |
|
std::pair<typename graph_traits<G>::out_edge_iterator, |
|
typename graph_traits<G>::out_edge_iterator> |
|
out_edges(typename graph_traits<G>::vertex_descriptor v, const subgraph<G>& g) |
|
{ return out_edges(v, g.m_graph); } |
|
|
|
template <typename G> |
|
typename graph_traits<G>::degree_size_type |
|
out_degree(typename graph_traits<G>::vertex_descriptor v, const subgraph<G>& g) |
|
{ return out_degree(v, g.m_graph); } |
|
|
|
template <typename G> |
|
typename graph_traits<G>::vertex_descriptor |
|
source(typename graph_traits<G>::edge_descriptor e, const subgraph<G>& g) |
|
{ return source(e, g.m_graph); } |
|
|
|
template <typename G> |
|
typename graph_traits<G>::vertex_descriptor |
|
target(typename graph_traits<G>::edge_descriptor e, const subgraph<G>& g) |
|
{ return target(e, g.m_graph); } |
|
|
|
//=========================================================================== |
|
// Functions required by the BidirectionalGraph concept |
|
|
|
template <typename G> |
|
std::pair<typename graph_traits<G>::in_edge_iterator, |
|
typename graph_traits<G>::in_edge_iterator> |
|
in_edges(typename graph_traits<G>::vertex_descriptor v, const subgraph<G>& g) |
|
{ return in_edges(v, g.m_graph); } |
|
|
|
template <typename G> |
|
typename graph_traits<G>::degree_size_type |
|
in_degree(typename graph_traits<G>::vertex_descriptor v, const subgraph<G>& g) |
|
{ return in_degree(v, g.m_graph); } |
|
|
|
template <typename G> |
|
typename graph_traits<G>::degree_size_type |
|
degree(typename graph_traits<G>::vertex_descriptor v, const subgraph<G>& g) |
|
{ return degree(v, g.m_graph); } |
|
|
|
//=========================================================================== |
|
// Functions required by the AdjacencyGraph concept |
|
|
|
template <typename G> |
|
std::pair<typename subgraph<G>::adjacency_iterator, |
|
typename subgraph<G>::adjacency_iterator> |
|
adjacent_vertices(typename subgraph<G>::vertex_descriptor v, const subgraph<G>& g) |
|
{ return adjacent_vertices(v, g.m_graph); } |
|
|
|
//=========================================================================== |
|
// Functions required by the VertexListGraph concept |
|
|
|
template <typename G> |
|
std::pair<typename subgraph<G>::vertex_iterator, |
|
typename subgraph<G>::vertex_iterator> |
|
vertices(const subgraph<G>& g) |
|
{ return vertices(g.m_graph); } |
|
|
|
template <typename G> |
|
typename subgraph<G>::vertices_size_type |
|
num_vertices(const subgraph<G>& g) |
|
{ return num_vertices(g.m_graph); } |
|
|
|
//=========================================================================== |
|
// Functions required by the EdgeListGraph concept |
|
|
|
template <typename G> |
|
std::pair<typename subgraph<G>::edge_iterator, |
|
typename subgraph<G>::edge_iterator> |
|
edges(const subgraph<G>& g) |
|
{ return edges(g.m_graph); } |
|
|
|
template <typename G> |
|
typename subgraph<G>::edges_size_type |
|
num_edges(const subgraph<G>& g) |
|
{ return num_edges(g.m_graph); } |
|
|
|
//=========================================================================== |
|
// Functions required by the AdjacencyMatrix concept |
|
|
|
template <typename G> |
|
std::pair<typename subgraph<G>::edge_descriptor, bool> |
|
edge(typename subgraph<G>::vertex_descriptor u, |
|
typename subgraph<G>::vertex_descriptor v, |
|
const subgraph<G>& g) |
|
{ return edge(u, v, g.m_graph); } |
|
|
|
//=========================================================================== |
|
// Functions required by the MutableGraph concept |
|
|
|
namespace detail { |
|
|
|
template <typename Vertex, typename Edge, typename Graph> |
|
void add_edge_recur_down(Vertex u_global, Vertex v_global, Edge e_global, |
|
subgraph<Graph>& g); |
|
|
|
template <typename Vertex, typename Edge, typename Children, typename G> |
|
void children_add_edge(Vertex u_global, Vertex v_global, Edge e_global, |
|
Children& c, subgraph<G>* orig) |
|
{ |
|
for(typename Children::iterator i = c.begin(); i != c.end(); ++i) { |
|
if ((*i)->find_vertex(u_global).second && |
|
(*i)->find_vertex(v_global).second) |
|
{ |
|
add_edge_recur_down(u_global, v_global, e_global, **i, orig); |
|
} |
|
} |
|
} |
|
|
|
template <typename Vertex, typename Edge, typename Graph> |
|
void add_edge_recur_down(Vertex u_global, Vertex v_global, Edge e_global, |
|
subgraph<Graph>& g, subgraph<Graph>* orig) |
|
{ |
|
if(&g != orig ) { |
|
// add local edge only if u_global and v_global are in subgraph g |
|
Vertex u_local, v_local; |
|
bool u_in_subgraph, v_in_subgraph; |
|
boost::tie(u_local, u_in_subgraph) = g.find_vertex(u_global); |
|
boost::tie(v_local, v_in_subgraph) = g.find_vertex(v_global); |
|
if(u_in_subgraph && v_in_subgraph) { |
|
g.local_add_edge(u_local, v_local, e_global); |
|
} |
|
} |
|
children_add_edge(u_global, v_global, e_global, g.m_children, orig); |
|
} |
|
|
|
template <typename Vertex, typename Graph> |
|
std::pair<typename subgraph<Graph>::edge_descriptor, bool> |
|
add_edge_recur_up(Vertex u_global, Vertex v_global, |
|
const typename Graph::edge_property_type& ep, |
|
subgraph<Graph>& g, subgraph<Graph>* orig) |
|
{ |
|
if(g.is_root()) { |
|
typename subgraph<Graph>::edge_descriptor e_global; |
|
bool inserted; |
|
boost::tie(e_global, inserted) = add_edge(u_global, v_global, ep, g.m_graph); |
|
put(edge_index, g.m_graph, e_global, g.m_edge_counter++); |
|
g.m_global_edge.push_back(e_global); |
|
children_add_edge(u_global, v_global, e_global, g.m_children, orig); |
|
return std::make_pair(e_global, inserted); |
|
} else { |
|
return add_edge_recur_up(u_global, v_global, ep, *g.m_parent, orig); |
|
} |
|
} |
|
|
|
} // namespace detail |
|
|
|
// Add an edge to the subgraph g, specified by the local vertex descriptors u |
|
// and v. In addition, the edge will be added to any (all) other subgraphs that |
|
// contain vertex descriptors u and v. |
|
|
|
template <typename G> |
|
std::pair<typename subgraph<G>::edge_descriptor, bool> |
|
add_edge(typename subgraph<G>::vertex_descriptor u, |
|
typename subgraph<G>::vertex_descriptor v, |
|
const typename G::edge_property_type& ep, |
|
subgraph<G>& g) |
|
{ |
|
if (g.is_root()) { |
|
// u and v are really global |
|
return detail::add_edge_recur_up(u, v, ep, g, &g); |
|
} else { |
|
typename subgraph<G>::edge_descriptor e_local, e_global; |
|
bool inserted; |
|
boost::tie(e_global, inserted) = |
|
detail::add_edge_recur_up(g.local_to_global(u), |
|
g.local_to_global(v), |
|
ep, g, &g); |
|
e_local = g.local_add_edge(u, v, e_global); |
|
return std::make_pair(e_local, inserted); |
|
} |
|
} |
|
|
|
template <typename G> |
|
std::pair<typename subgraph<G>::edge_descriptor, bool> |
|
add_edge(typename subgraph<G>::vertex_descriptor u, |
|
typename subgraph<G>::vertex_descriptor v, |
|
subgraph<G>& g) |
|
{ return add_edge(u, v, typename G::edge_property_type(), g); } |
|
|
|
namespace detail { |
|
//------------------------------------------------------------------------- |
|
// implementation of remove_edge(u,v,g) |
|
template <typename Vertex, typename Graph> |
|
void remove_edge_recur_down(Vertex u_global, Vertex v_global, |
|
subgraph<Graph>& g); |
|
|
|
template <typename Vertex, typename Children> |
|
void children_remove_edge(Vertex u_global, Vertex v_global, |
|
Children& c) |
|
{ |
|
for(typename Children::iterator i = c.begin(); i != c.end(); ++i) { |
|
if((*i)->find_vertex(u_global).second && |
|
(*i)->find_vertex(v_global).second) |
|
{ |
|
remove_edge_recur_down(u_global, v_global, **i); |
|
} |
|
} |
|
} |
|
|
|
template <typename Vertex, typename Graph> |
|
void remove_edge_recur_down(Vertex u_global, Vertex v_global, |
|
subgraph<Graph>& g) |
|
{ |
|
Vertex u_local, v_local; |
|
u_local = g.m_local_vertex[u_global]; |
|
v_local = g.m_local_vertex[v_global]; |
|
remove_edge(u_local, v_local, g.m_graph); |
|
children_remove_edge(u_global, v_global, g.m_children); |
|
} |
|
|
|
template <typename Vertex, typename Graph> |
|
void remove_edge_recur_up(Vertex u_global, Vertex v_global, |
|
subgraph<Graph>& g) |
|
{ |
|
if(g.is_root()) { |
|
remove_edge(u_global, v_global, g.m_graph); |
|
children_remove_edge(u_global, v_global, g.m_children); |
|
} else { |
|
remove_edge_recur_up(u_global, v_global, *g.m_parent); |
|
} |
|
} |
|
|
|
//------------------------------------------------------------------------- |
|
// implementation of remove_edge(e,g) |
|
|
|
template <typename G, typename Edge, typename Children> |
|
void children_remove_edge(Edge e_global, Children& c) |
|
{ |
|
for(typename Children::iterator i = c.begin(); i != c.end(); ++i) { |
|
std::pair<typename subgraph<G>::edge_descriptor, bool> found = |
|
(*i)->find_edge(e_global); |
|
if (!found.second) { |
|
continue; |
|
} |
|
children_remove_edge<G>(e_global, (*i)->m_children); |
|
remove_edge(found.first, (*i)->m_graph); |
|
} |
|
} |
|
|
|
} // namespace detail |
|
|
|
template <typename G> |
|
void |
|
remove_edge(typename subgraph<G>::vertex_descriptor u, |
|
typename subgraph<G>::vertex_descriptor v, |
|
subgraph<G>& g) |
|
{ |
|
if(g.is_root()) { |
|
detail::remove_edge_recur_up(u, v, g); |
|
} else { |
|
detail::remove_edge_recur_up(g.local_to_global(u), |
|
g.local_to_global(v), g); |
|
} |
|
} |
|
|
|
template <typename G> |
|
void |
|
remove_edge(typename subgraph<G>::edge_descriptor e, subgraph<G>& g) |
|
{ |
|
typename subgraph<G>::edge_descriptor e_global = g.local_to_global(e); |
|
#ifndef NDEBUG |
|
std::pair<typename subgraph<G>::edge_descriptor, bool> fe = g.find_edge(e_global); |
|
BOOST_ASSERT(fe.second && fe.first == e); |
|
#endif //NDEBUG |
|
subgraph<G> &root = g.root(); // chase to root |
|
detail::children_remove_edge<G>(e_global, root.m_children); |
|
remove_edge(e_global, root.m_graph); // kick edge from root |
|
} |
|
|
|
// This is slow, but there may not be a good way to do it safely otherwise |
|
template <typename Predicate, typename G> |
|
void |
|
remove_edge_if(Predicate p, subgraph<G>& g) { |
|
while (true) { |
|
bool any_removed = false; |
|
typedef typename subgraph<G>::edge_iterator ei_type; |
|
for (std::pair<ei_type, ei_type> ep = edges(g); |
|
ep.first != ep.second; ++ep.first) { |
|
if (p(*ep.first)) { |
|
any_removed = true; |
|
remove_edge(*ep.first, g); |
|
break; /* Since iterators may be invalidated */ |
|
} |
|
} |
|
if (!any_removed) break; |
|
} |
|
} |
|
|
|
template <typename G> |
|
void |
|
clear_vertex(typename subgraph<G>::vertex_descriptor v, subgraph<G>& g) { |
|
while (true) { |
|
typedef typename subgraph<G>::out_edge_iterator oei_type; |
|
std::pair<oei_type, oei_type> p = out_edges(v, g); |
|
if (p.first == p.second) break; |
|
remove_edge(*p.first, g); |
|
} |
|
} |
|
|
|
namespace detail { |
|
template <typename G> |
|
typename subgraph<G>::vertex_descriptor |
|
add_vertex_recur_up(subgraph<G>& g) |
|
{ |
|
typename subgraph<G>::vertex_descriptor u_local, u_global; |
|
if (g.is_root()) { |
|
u_global = add_vertex(g.m_graph); |
|
g.m_global_vertex.push_back(u_global); |
|
} else { |
|
u_global = add_vertex_recur_up(*g.m_parent); |
|
u_local = add_vertex(g.m_graph); |
|
g.m_global_vertex.push_back(u_global); |
|
g.m_local_vertex[u_global] = u_local; |
|
} |
|
return u_global; |
|
} |
|
} // namespace detail |
|
|
|
template <typename G> |
|
typename subgraph<G>::vertex_descriptor |
|
add_vertex(subgraph<G>& g) |
|
{ |
|
typename subgraph<G>::vertex_descriptor u_local, u_global; |
|
if(g.is_root()) { |
|
u_global = add_vertex(g.m_graph); |
|
g.m_global_vertex.push_back(u_global); |
|
u_local = u_global; |
|
} else { |
|
u_global = detail::add_vertex_recur_up(g.parent()); |
|
u_local = add_vertex(g.m_graph); |
|
g.m_global_vertex.push_back(u_global); |
|
g.m_local_vertex[u_global] = u_local; |
|
} |
|
return u_local; |
|
} |
|
|
|
|
|
#if 0 |
|
// TODO: Under Construction |
|
template <typename G> |
|
void remove_vertex(typename subgraph<G>::vertex_descriptor u, subgraph<G>& g) |
|
{ BOOST_ASSERT(false); } |
|
#endif |
|
|
|
//=========================================================================== |
|
// Functions required by the PropertyGraph concept |
|
|
|
/** |
|
* The global property map returns the global properties associated with local |
|
* descriptors. |
|
*/ |
|
template <typename GraphPtr, typename PropertyMap, typename Tag> |
|
class subgraph_global_property_map |
|
: public put_get_helper< |
|
typename property_traits<PropertyMap>::reference, |
|
subgraph_global_property_map<GraphPtr, PropertyMap, Tag> |
|
> |
|
{ |
|
typedef property_traits<PropertyMap> Traits; |
|
public: |
|
typedef typename mpl::if_<is_const<typename remove_pointer<GraphPtr>::type>, |
|
readable_property_map_tag, |
|
typename Traits::category>::type |
|
category; |
|
typedef typename Traits::value_type value_type; |
|
typedef typename Traits::key_type key_type; |
|
typedef typename Traits::reference reference; |
|
|
|
subgraph_global_property_map() |
|
{ } |
|
|
|
subgraph_global_property_map(GraphPtr g, Tag tag) |
|
: m_g(g), m_tag(tag) |
|
{ } |
|
|
|
reference operator[](key_type e) const { |
|
PropertyMap pmap = get(m_tag, m_g->root().m_graph); |
|
return m_g->is_root() |
|
? pmap[e] |
|
: pmap[m_g->local_to_global(e)]; |
|
} |
|
|
|
GraphPtr m_g; |
|
Tag m_tag; |
|
}; |
|
|
|
/** |
|
* The local property map returns the local property associated with the local |
|
* descriptors. |
|
*/ |
|
template <typename GraphPtr, typename PropertyMap, typename Tag> |
|
class subgraph_local_property_map |
|
: public put_get_helper< |
|
typename property_traits<PropertyMap>::reference, |
|
subgraph_local_property_map<GraphPtr, PropertyMap, Tag> |
|
> |
|
{ |
|
typedef property_traits<PropertyMap> Traits; |
|
public: |
|
typedef typename mpl::if_<is_const<typename remove_pointer<GraphPtr>::type>, |
|
readable_property_map_tag, |
|
typename Traits::category>::type |
|
category; |
|
typedef typename Traits::value_type value_type; |
|
typedef typename Traits::key_type key_type; |
|
typedef typename Traits::reference reference; |
|
|
|
typedef Tag tag; |
|
typedef PropertyMap pmap; |
|
|
|
subgraph_local_property_map() |
|
{ } |
|
|
|
subgraph_local_property_map(GraphPtr g, Tag tag) |
|
: m_g(g), m_tag(tag) |
|
{ } |
|
|
|
reference operator[](key_type e) const { |
|
// Get property map on the underlying graph. |
|
PropertyMap pmap = get(m_tag, m_g->m_graph); |
|
return pmap[e]; |
|
} |
|
|
|
GraphPtr m_g; |
|
Tag m_tag; |
|
}; |
|
|
|
namespace detail { |
|
// Extract the actual tags from local or global property maps so we don't |
|
// try to find non-properties. |
|
template <typename P> struct extract_lg_tag { typedef P type; }; |
|
template <typename P> struct extract_lg_tag< local_property<P> > { |
|
typedef P type; |
|
}; |
|
template <typename P> struct extract_lg_tag< global_property<P> > { |
|
typedef P type; |
|
}; |
|
|
|
// NOTE: Mysterious Property template parameter unused in both metafunction |
|
// classes. |
|
struct subgraph_global_pmap { |
|
template <class Tag, class SubGraph, class Property> |
|
struct bind_ { |
|
typedef typename SubGraph::graph_type Graph; |
|
typedef SubGraph* SubGraphPtr; |
|
typedef const SubGraph* const_SubGraphPtr; |
|
typedef typename extract_lg_tag<Tag>::type TagType; |
|
typedef typename property_map<Graph, TagType>::type PMap; |
|
typedef typename property_map<Graph, TagType>::const_type const_PMap; |
|
public: |
|
typedef subgraph_global_property_map<SubGraphPtr, PMap, TagType> type; |
|
typedef subgraph_global_property_map<const_SubGraphPtr, const_PMap, TagType> |
|
const_type; |
|
}; |
|
}; |
|
|
|
struct subgraph_local_pmap { |
|
template <class Tag, class SubGraph, class Property> |
|
struct bind_ { |
|
typedef typename SubGraph::graph_type Graph; |
|
typedef SubGraph* SubGraphPtr; |
|
typedef const SubGraph* const_SubGraphPtr; |
|
typedef typename extract_lg_tag<Tag>::type TagType; |
|
typedef typename property_map<Graph, TagType>::type PMap; |
|
typedef typename property_map<Graph, TagType>::const_type const_PMap; |
|
public: |
|
typedef subgraph_local_property_map<SubGraphPtr, PMap, TagType> type; |
|
typedef subgraph_local_property_map<const_SubGraphPtr, const_PMap, TagType> |
|
const_type; |
|
}; |
|
}; |
|
|
|
// These metafunctions select the corresponding metafunctions above, and |
|
// are used by the choose_pmap metafunction below to specialize the choice |
|
// of local/global property map. By default, we defer to the global |
|
// property. |
|
template <class Tag> |
|
struct subgraph_choose_pmap_helper { |
|
typedef subgraph_global_pmap type; |
|
}; |
|
template <class Tag> |
|
struct subgraph_choose_pmap_helper< local_property<Tag> > { |
|
typedef subgraph_local_pmap type; |
|
}; |
|
template <class Tag> |
|
struct subgraph_choose_pmap_helper< global_property<Tag> > { |
|
typedef subgraph_global_pmap type; |
|
}; |
|
|
|
// As above, unless we're requesting vertex_index_t. Then it's always a |
|
// local property map. This enables the correct translation of descriptors |
|
// between local and global layers. |
|
template <> |
|
struct subgraph_choose_pmap_helper<vertex_index_t> { |
|
typedef subgraph_local_pmap type; |
|
}; |
|
template <> |
|
struct subgraph_choose_pmap_helper< local_property<vertex_index_t> > { |
|
typedef subgraph_local_pmap type; |
|
}; |
|
template <> |
|
struct subgraph_choose_pmap_helper< global_property<vertex_index_t> > { |
|
typedef subgraph_local_pmap type; |
|
}; |
|
|
|
// Determine the kind of property. If SameType<Tag, vertex_index_t>, then |
|
// the property lookup is always local. Otherwise, the lookup is global. |
|
// NOTE: Property parameter is basically unused. |
|
template <class Tag, class Graph, class Property> |
|
struct subgraph_choose_pmap { |
|
typedef typename subgraph_choose_pmap_helper<Tag>::type Helper; |
|
typedef typename Helper::template bind_<Tag, Graph, Property> Bind; |
|
typedef typename Bind::type type; |
|
typedef typename Bind::const_type const_type; |
|
}; |
|
|
|
// Used by the vertex/edge property selectors to determine the kind(s) of |
|
// property maps used by the property_map type generator. |
|
struct subgraph_property_generator { |
|
template <class SubGraph, class Property, class Tag> |
|
struct bind_ { |
|
typedef subgraph_choose_pmap<Tag, SubGraph, Property> Choice; |
|
typedef typename Choice::type type; |
|
typedef typename Choice::const_type const_type; |
|
}; |
|
}; |
|
|
|
} // namespace detail |
|
|
|
template <> |
|
struct vertex_property_selector<subgraph_tag> { |
|
typedef detail::subgraph_property_generator type; |
|
}; |
|
|
|
template <> |
|
struct edge_property_selector<subgraph_tag> { |
|
typedef detail::subgraph_property_generator type; |
|
}; |
|
|
|
// ================================================== |
|
// get(p, g), get(p, g, k), and put(p, g, k, v) |
|
// ================================================== |
|
template <typename G, typename Property> |
|
typename property_map<subgraph<G>, Property>::type |
|
get(Property p, subgraph<G>& g) { |
|
typedef typename property_map< subgraph<G>, Property>::type PMap; |
|
return PMap(&g, p); |
|
} |
|
|
|
template <typename G, typename Property> |
|
typename property_map<subgraph<G>, Property>::const_type |
|
get(Property p, const subgraph<G>& g) { |
|
typedef typename property_map< subgraph<G>, Property>::const_type PMap; |
|
return PMap(&g, p); |
|
} |
|
|
|
template <typename G, typename Property, typename Key> |
|
typename property_traits< |
|
typename property_map<subgraph<G>, Property>::const_type |
|
>::value_type |
|
get(Property p, const subgraph<G>& g, const Key& k) { |
|
typedef typename property_map< subgraph<G>, Property>::const_type PMap; |
|
PMap pmap(&g, p); |
|
return pmap[k]; |
|
} |
|
|
|
template <typename G, typename Property, typename Key, typename Value> |
|
void put(Property p, subgraph<G>& g, const Key& k, const Value& val) { |
|
typedef typename property_map< subgraph<G>, Property>::type PMap; |
|
PMap pmap(&g, p); |
|
pmap[k] = val; |
|
} |
|
|
|
// ================================================== |
|
// get(global(p), g) |
|
// NOTE: get(global(p), g, k) and put(global(p), g, k, v) not supported |
|
// ================================================== |
|
template <typename G, typename Property> |
|
typename property_map<subgraph<G>, global_property<Property> >::type |
|
get(global_property<Property> p, subgraph<G>& g) { |
|
typedef typename property_map< |
|
subgraph<G>, global_property<Property> |
|
>::type Map; |
|
return Map(&g, p.value); |
|
} |
|
|
|
template <typename G, typename Property> |
|
typename property_map<subgraph<G>, global_property<Property> >::const_type |
|
get(global_property<Property> p, const subgraph<G>& g) { |
|
typedef typename property_map< |
|
subgraph<G>, global_property<Property> |
|
>::const_type Map; |
|
return Map(&g, p.value); |
|
} |
|
|
|
// ================================================== |
|
// get(local(p), g) |
|
// NOTE: get(local(p), g, k) and put(local(p), g, k, v) not supported |
|
// ================================================== |
|
template <typename G, typename Property> |
|
typename property_map<subgraph<G>, local_property<Property> >::type |
|
get(local_property<Property> p, subgraph<G>& g) { |
|
typedef typename property_map< |
|
subgraph<G>, local_property<Property> |
|
>::type Map; |
|
return Map(&g, p.value); |
|
} |
|
|
|
template <typename G, typename Property> |
|
typename property_map<subgraph<G>, local_property<Property> >::const_type |
|
get(local_property<Property> p, const subgraph<G>& g) { |
|
typedef typename property_map< |
|
subgraph<G>, local_property<Property> |
|
>::const_type Map; |
|
return Map(&g, p.value); |
|
} |
|
|
|
template <typename G, typename Tag> |
|
inline typename graph_property<G, Tag>::type& |
|
get_property(subgraph<G>& g, Tag tag) { |
|
return get_property(g.m_graph, tag); |
|
} |
|
|
|
template <typename G, typename Tag> |
|
inline const typename graph_property<G, Tag>::type& |
|
get_property(const subgraph<G>& g, Tag tag) { |
|
return get_property(g.m_graph, tag); |
|
} |
|
|
|
//=========================================================================== |
|
// Miscellaneous Functions |
|
|
|
template <typename G> |
|
typename subgraph<G>::vertex_descriptor |
|
vertex(typename subgraph<G>::vertices_size_type n, const subgraph<G>& g) |
|
{ return vertex(n, g.m_graph); } |
|
|
|
//=========================================================================== |
|
// Mutability Traits |
|
// Just pull the mutability traits form the underlying graph. Note that this |
|
// will probably fail (badly) for labeled graphs. |
|
template <typename G> |
|
struct graph_mutability_traits< subgraph<G> > { |
|
typedef typename graph_mutability_traits<G>::category category; |
|
}; |
|
|
|
} // namespace boost |
|
|
|
#endif // BOOST_SUBGRAPH_HPP
|
|
|