You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and dots ('.'), can be up to 35 characters long. Letters must be lowercase.
684 lines
22 KiB
684 lines
22 KiB
// (C) Copyright 2007-2009 Andrew Sutton |
|
// |
|
// Use, modification and distribution are subject to the |
|
// Boost Software License, Version 1.0 (See accompanying file |
|
// LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt) |
|
|
|
#ifndef BOOST_GRAPH_DIRECTED_GRAPH_HPP |
|
#define BOOST_GRAPH_DIRECTED_GRAPH_HPP |
|
|
|
#include <boost/utility.hpp> |
|
#include <boost/graph/adjacency_list.hpp> |
|
#include <boost/graph/properties.hpp> |
|
|
|
namespace boost |
|
{ |
|
struct directed_graph_tag { }; |
|
|
|
/** |
|
* The directed_graph class template is a simplified version of the BGL |
|
* adjacency list. This class is provided for ease of use, but may not |
|
* perform as well as custom-defined adjacency list classes. Instances of |
|
* this template model the BidirectionalGraph, VertexIndexGraph, and |
|
* EdgeIndexGraph concepts. The graph is also fully mutable, supporting |
|
* both insertions and removals of vertices and edges. |
|
* |
|
* @note Special care must be taken when removing vertices or edges since |
|
* those operations can invalidate the numbering of vertices. |
|
*/ |
|
template < |
|
typename VertexProp = no_property, |
|
typename EdgeProp= no_property, |
|
typename GraphProp= no_property> |
|
class directed_graph |
|
{ |
|
public: |
|
typedef typename graph_detail::graph_prop<GraphProp>::property graph_property_type; |
|
typedef typename graph_detail::graph_prop<GraphProp>::bundle graph_bundled; |
|
|
|
typedef typename graph_detail::vertex_prop<VertexProp>::property vertex_property_type; |
|
typedef typename graph_detail::vertex_prop<VertexProp>::bundle vertex_bundled; |
|
|
|
typedef typename graph_detail::edge_prop<EdgeProp>::property edge_property_type; |
|
typedef typename graph_detail::edge_prop<EdgeProp>::bundle edge_bundled; |
|
|
|
private: |
|
// Wrap the user-specified properties with an index. |
|
typedef property<vertex_index_t, unsigned, vertex_property_type> vertex_property; |
|
typedef property<edge_index_t, unsigned, edge_property_type> edge_property; |
|
|
|
public: |
|
typedef adjacency_list< |
|
listS, listS, bidirectionalS, |
|
vertex_property, edge_property, GraphProp, |
|
listS |
|
> graph_type; |
|
|
|
private: |
|
// storage selectors |
|
typedef typename graph_type::vertex_list_selector vertex_list_selector; |
|
typedef typename graph_type::edge_list_selector edge_list_selector; |
|
typedef typename graph_type::out_edge_list_selector out_edge_list_selector; |
|
typedef typename graph_type::directed_selector directed_selector; |
|
|
|
public: |
|
// more commonly used graph types |
|
typedef typename graph_type::stored_vertex stored_vertex; |
|
typedef typename graph_type::vertices_size_type vertices_size_type; |
|
typedef typename graph_type::edges_size_type edges_size_type; |
|
typedef typename graph_type::degree_size_type degree_size_type; |
|
typedef typename graph_type::vertex_descriptor vertex_descriptor; |
|
typedef typename graph_type::edge_descriptor edge_descriptor; |
|
|
|
// iterator types |
|
typedef typename graph_type::vertex_iterator vertex_iterator; |
|
typedef typename graph_type::edge_iterator edge_iterator; |
|
typedef typename graph_type::out_edge_iterator out_edge_iterator; |
|
typedef typename graph_type::in_edge_iterator in_edge_iterator; |
|
typedef typename graph_type::adjacency_iterator adjacency_iterator; |
|
|
|
// miscellaneous types |
|
typedef directed_graph_tag graph_tag; |
|
typedef typename graph_type::directed_category directed_category; |
|
typedef typename graph_type::edge_parallel_category edge_parallel_category; |
|
typedef typename graph_type::traversal_category traversal_category; |
|
|
|
typedef unsigned vertex_index_type; |
|
typedef unsigned edge_index_type; |
|
|
|
directed_graph(GraphProp const& p = GraphProp()) |
|
: m_graph(p), m_num_vertices(0), m_num_edges(0), m_max_vertex_index(0) |
|
, m_max_edge_index(0) |
|
{ } |
|
|
|
directed_graph(directed_graph const& x) |
|
: m_graph(x), m_num_vertices(x.m_num_vertices), m_num_edges(x.m_num_edges) |
|
, m_max_vertex_index(x.m_max_vertex_index), m_max_edge_index(x.m_max_edge_index) |
|
{ } |
|
|
|
directed_graph(vertices_size_type n, GraphProp const& p = GraphProp()) |
|
: m_graph(n, p), m_num_vertices(n), m_num_edges(0), m_max_vertex_index(n) |
|
, m_max_edge_index(0) |
|
{ renumber_vertex_indices(); } |
|
|
|
template <typename EdgeIterator> |
|
directed_graph(EdgeIterator f, |
|
EdgeIterator l, |
|
vertices_size_type n, |
|
edges_size_type m = 0, |
|
GraphProp const& p = GraphProp()) |
|
: m_graph(f, l, n, m, p), m_num_vertices(n), m_num_edges(0) |
|
, m_max_vertex_index(n), m_max_edge_index(0) |
|
{ |
|
// Unfortunately, we have to renumber the entire graph. |
|
renumber_indices(); |
|
|
|
// Can't always guarantee that the number of edges is actually |
|
// m if distance(f, l) != m (or is undefined). |
|
m_num_edges = m_max_edge_index = boost::num_edges(m_graph); |
|
} |
|
|
|
directed_graph& operator=(directed_graph const& g) { |
|
if(&g != this) { |
|
m_graph = g.m_graph; |
|
m_num_vertices = g.m_num_vertices; |
|
m_num_edges = g.m_num_edges; |
|
m_max_vertex_index = g.m_max_vertex_index; |
|
m_max_edge_index = g.m_max_edge_index; |
|
} |
|
return *this; |
|
} |
|
|
|
// The impl_() methods are not part of the public interface. |
|
graph_type& impl() |
|
{ return m_graph; } |
|
|
|
graph_type const& impl() const |
|
{ return m_graph; } |
|
|
|
// The following methods are not part of the public interface |
|
vertices_size_type num_vertices() const |
|
{ return m_num_vertices; } |
|
|
|
private: |
|
// This helper function manages the attribution of vertex indices. |
|
vertex_descriptor make_index(vertex_descriptor v) { |
|
boost::put(vertex_index, m_graph, v, m_max_vertex_index); |
|
m_num_vertices++; |
|
m_max_vertex_index++; |
|
return v; |
|
} |
|
public: |
|
vertex_descriptor add_vertex() |
|
{ return make_index(boost::add_vertex(m_graph)); } |
|
|
|
vertex_descriptor add_vertex(vertex_property_type const& p) |
|
{ return make_index(boost::add_vertex(vertex_property(0u, p), m_graph)); } |
|
|
|
void clear_vertex(vertex_descriptor v) |
|
{ |
|
m_num_edges -= boost::degree(v, m_graph); |
|
boost::clear_vertex(v, m_graph); |
|
} |
|
|
|
void remove_vertex(vertex_descriptor v) |
|
{ |
|
boost::remove_vertex(v, m_graph); |
|
--m_num_vertices; |
|
} |
|
|
|
edges_size_type num_edges() const |
|
{ return m_num_edges; } |
|
|
|
private: |
|
// A helper fucntion for managing edge index attributes. |
|
std::pair<edge_descriptor, bool> const& |
|
make_index(std::pair<edge_descriptor, bool> const& x) |
|
{ |
|
if(x.second) { |
|
boost::put(edge_index, m_graph, x.first, m_max_edge_index); |
|
++m_num_edges; |
|
++m_max_edge_index; |
|
} |
|
return x; |
|
} |
|
public: |
|
std::pair<edge_descriptor, bool> |
|
add_edge(vertex_descriptor u, vertex_descriptor v) |
|
{ return make_index(boost::add_edge(u, v, m_graph)); } |
|
|
|
std::pair<edge_descriptor, bool> |
|
add_edge(vertex_descriptor u, vertex_descriptor v, edge_property_type const& p) |
|
{ return make_index(boost::add_edge(u, v, edge_property(0u, p), m_graph)); } |
|
|
|
void remove_edge(vertex_descriptor u, vertex_descriptor v) |
|
{ |
|
// find all edges, (u, v) |
|
std::vector<edge_descriptor> edges; |
|
out_edge_iterator i, i_end; |
|
for(boost::tie(i, i_end) = boost::out_edges(u, m_graph); i != i_end; ++i) { |
|
if(boost::target(*i, m_graph) == v) { |
|
edges.push_back(*i); |
|
} |
|
} |
|
// remove all edges, (u, v) |
|
typename std::vector<edge_descriptor>::iterator |
|
j = edges.begin(), j_end = edges.end(); |
|
for( ; j != j_end; ++j) { |
|
remove_edge(*j); |
|
} |
|
} |
|
|
|
void remove_edge(edge_iterator i) |
|
{ |
|
remove_edge(*i); |
|
} |
|
|
|
void remove_edge(edge_descriptor e) |
|
{ |
|
boost::remove_edge(e, m_graph); |
|
--m_num_edges; |
|
} |
|
|
|
vertex_index_type max_vertex_index() const |
|
{ return m_max_vertex_index; } |
|
|
|
void |
|
renumber_vertex_indices() |
|
{ |
|
vertex_iterator i, end; |
|
boost::tie(i, end) = vertices(m_graph); |
|
m_max_vertex_index = renumber_vertex_indices(i, end, 0); |
|
} |
|
|
|
void |
|
remove_vertex_and_renumber_indices(vertex_iterator i) |
|
{ |
|
vertex_iterator j = next(i), end = vertices(m_graph).second; |
|
vertex_index_type n = get(vertex_index, m_graph, *i); |
|
|
|
// remove the offending vertex and renumber everything after |
|
remove_vertex(*i); |
|
m_max_vertex_index = renumber_vertex_indices(j, end, n); |
|
} |
|
|
|
edge_index_type |
|
max_edge_index() const |
|
{ return m_max_edge_index; } |
|
|
|
void |
|
renumber_edge_indices() |
|
{ |
|
edge_iterator i, end; |
|
boost::tie(i, end) = edges(m_graph); |
|
m_max_edge_index = renumber_edge_indices(i, end, 0); |
|
} |
|
|
|
void |
|
remove_edge_and_renumber_indices(edge_iterator i) |
|
{ |
|
edge_iterator j = next(i), end = edges(m_graph).second; |
|
edge_index_type n = get(edge_index, m_graph, *i); |
|
|
|
// remove the offending edge and renumber everything after |
|
remove_edge(*i); |
|
m_max_edge_index = renumber_edge_indices(j, end, n); |
|
} |
|
|
|
void |
|
renumber_indices() |
|
{ |
|
renumber_vertex_indices(); |
|
renumber_edge_indices(); |
|
} |
|
|
|
// bundled property support |
|
#ifndef BOOST_GRAPH_NO_BUNDLED_PROPERTIES |
|
vertex_bundled& operator[](vertex_descriptor v) |
|
{ return m_graph[v]; } |
|
|
|
vertex_bundled const& operator[](vertex_descriptor v) const |
|
{ return m_graph[v]; } |
|
|
|
edge_bundled& operator[](edge_descriptor e) |
|
{ return m_graph[e]; } |
|
|
|
edge_bundled const& operator[](edge_descriptor e) const |
|
{ return m_graph[e]; } |
|
|
|
graph_bundled& operator[](graph_bundle_t) |
|
{ return get_property(*this); } |
|
|
|
graph_bundled const& operator[](graph_bundle_t) const |
|
{ return get_property(*this); } |
|
#endif |
|
|
|
// Graph concepts |
|
static vertex_descriptor null_vertex() |
|
{ return graph_type::null_vertex(); } |
|
|
|
void clear() |
|
{ |
|
m_graph.clear(); |
|
m_num_vertices = m_max_vertex_index = 0; |
|
m_num_edges = m_max_edge_index = 0; |
|
} |
|
|
|
void swap(directed_graph& g) |
|
{ |
|
m_graph.swap(g); |
|
std::swap(m_num_vertices, g.m_num_vertices); |
|
std::swap(m_max_vertex_index, g.m_max_vertex_index); |
|
std::swap(m_num_edges, g.m_num_edges); |
|
std::swap(m_max_edge_index, g.m_max_edge_index); |
|
} |
|
|
|
private: |
|
vertices_size_type |
|
renumber_vertex_indices(vertex_iterator i, |
|
vertex_iterator end, |
|
vertices_size_type n) |
|
{ |
|
typedef typename property_map<graph_type, vertex_index_t>::type IndexMap; |
|
IndexMap indices = get(vertex_index, m_graph); |
|
for( ; i != end; ++i) { |
|
indices[*i] = n++; |
|
} |
|
return n; |
|
} |
|
|
|
vertices_size_type |
|
renumber_edge_indices(edge_iterator i, |
|
edge_iterator end, |
|
vertices_size_type n) |
|
{ |
|
typedef typename property_map<graph_type, edge_index_t>::type IndexMap; |
|
IndexMap indices = get(edge_index, m_graph); |
|
for( ; i != end; ++i) { |
|
indices[*i] = n++; |
|
} |
|
return n; |
|
} |
|
|
|
graph_type m_graph; |
|
vertices_size_type m_num_vertices; |
|
edges_size_type m_num_edges; |
|
vertex_index_type m_max_vertex_index; |
|
edge_index_type m_max_edge_index; |
|
}; |
|
|
|
#define DIRECTED_GRAPH_PARAMS typename VP, typename EP, typename GP |
|
#define DIRECTED_GRAPH directed_graph<VP,EP,GP> |
|
|
|
// IncidenceGraph concepts |
|
template <DIRECTED_GRAPH_PARAMS> |
|
inline typename DIRECTED_GRAPH::vertex_descriptor |
|
source(typename DIRECTED_GRAPH::edge_descriptor e, DIRECTED_GRAPH const& g) |
|
{ return source(e, g.impl()); } |
|
|
|
template <DIRECTED_GRAPH_PARAMS> |
|
inline typename DIRECTED_GRAPH::vertex_descriptor |
|
target(typename DIRECTED_GRAPH::edge_descriptor e, DIRECTED_GRAPH const& g) |
|
{ return target(e, g.impl()); } |
|
|
|
template <DIRECTED_GRAPH_PARAMS> |
|
inline typename DIRECTED_GRAPH::degree_size_type |
|
out_degree(typename DIRECTED_GRAPH::vertex_descriptor v, DIRECTED_GRAPH const& g) |
|
{ return out_degree(v, g.impl()); } |
|
|
|
template <DIRECTED_GRAPH_PARAMS> |
|
inline std::pair< |
|
typename DIRECTED_GRAPH::out_edge_iterator, |
|
typename DIRECTED_GRAPH::out_edge_iterator |
|
> |
|
out_edges(typename DIRECTED_GRAPH::vertex_descriptor v, |
|
DIRECTED_GRAPH const& g) |
|
{ return out_edges(v, g.impl()); } |
|
|
|
// BidirectionalGraph concepts |
|
template <DIRECTED_GRAPH_PARAMS> |
|
inline typename DIRECTED_GRAPH::degree_size_type |
|
in_degree(typename DIRECTED_GRAPH::vertex_descriptor v, DIRECTED_GRAPH const& g) |
|
{ return in_degree(v, g.impl()); } |
|
|
|
template <DIRECTED_GRAPH_PARAMS> |
|
inline std::pair< |
|
typename DIRECTED_GRAPH::in_edge_iterator, |
|
typename DIRECTED_GRAPH::in_edge_iterator |
|
> |
|
in_edges(typename DIRECTED_GRAPH::vertex_descriptor v, |
|
DIRECTED_GRAPH const& g) |
|
{ return in_edges(v, g.impl()); } |
|
|
|
|
|
template <DIRECTED_GRAPH_PARAMS> |
|
inline typename DIRECTED_GRAPH::degree_size_type |
|
degree(typename DIRECTED_GRAPH::vertex_descriptor v, DIRECTED_GRAPH const& g) |
|
{ return degree(v, g.impl()); } |
|
|
|
// AdjacencyGraph concepts |
|
template <DIRECTED_GRAPH_PARAMS> |
|
inline std::pair< |
|
typename DIRECTED_GRAPH::adjacency_iterator, |
|
typename DIRECTED_GRAPH::adjacency_iterator |
|
> |
|
adjacent_vertices(typename DIRECTED_GRAPH::vertex_descriptor v, |
|
DIRECTED_GRAPH const& g) |
|
{ return adjacent_vertices(v, g.impl()); } |
|
|
|
template <DIRECTED_GRAPH_PARAMS> |
|
typename DIRECTED_GRAPH::vertex_descriptor |
|
vertex(typename DIRECTED_GRAPH::vertices_size_type n, |
|
DIRECTED_GRAPH const& g) |
|
{ return vertex(g.impl()); } |
|
|
|
template <DIRECTED_GRAPH_PARAMS> |
|
std::pair<typename DIRECTED_GRAPH::edge_descriptor, bool> |
|
edge(typename DIRECTED_GRAPH::vertex_descriptor u, |
|
typename DIRECTED_GRAPH::vertex_descriptor v, |
|
DIRECTED_GRAPH const& g) |
|
{ return edge(u, v, g.impl()); } |
|
|
|
// VertexListGraph concepts |
|
template <DIRECTED_GRAPH_PARAMS> |
|
inline typename DIRECTED_GRAPH::vertices_size_type |
|
num_vertices(DIRECTED_GRAPH const& g) |
|
{ return g.num_vertices(); } |
|
|
|
template <DIRECTED_GRAPH_PARAMS> |
|
inline std::pair< |
|
typename DIRECTED_GRAPH::vertex_iterator, |
|
typename DIRECTED_GRAPH::vertex_iterator |
|
> |
|
vertices(DIRECTED_GRAPH const& g) |
|
{ return vertices(g.impl()); } |
|
|
|
// EdgeListGraph concepts |
|
template <DIRECTED_GRAPH_PARAMS> |
|
inline typename DIRECTED_GRAPH::edges_size_type |
|
num_edges(DIRECTED_GRAPH const& g) |
|
{ return g.num_edges(); } |
|
|
|
template <DIRECTED_GRAPH_PARAMS> |
|
inline std::pair< |
|
typename DIRECTED_GRAPH::edge_iterator, |
|
typename DIRECTED_GRAPH::edge_iterator |
|
> |
|
edges(DIRECTED_GRAPH const& g) |
|
{ return edges(g.impl()); } |
|
|
|
// MutableGraph concepts |
|
template <DIRECTED_GRAPH_PARAMS> |
|
inline typename DIRECTED_GRAPH::vertex_descriptor |
|
add_vertex(DIRECTED_GRAPH& g) |
|
{ return g.add_vertex(); } |
|
|
|
template <DIRECTED_GRAPH_PARAMS> |
|
inline typename DIRECTED_GRAPH::vertex_descriptor |
|
add_vertex(typename DIRECTED_GRAPH::vertex_property_type const& p, |
|
DIRECTED_GRAPH& g) |
|
{ return g.add_vertex(p); } |
|
|
|
template <DIRECTED_GRAPH_PARAMS> |
|
inline void |
|
clear_vertex(typename DIRECTED_GRAPH::vertex_descriptor v, |
|
DIRECTED_GRAPH& g) |
|
{ return g.clear_vertex(v); } |
|
|
|
template <DIRECTED_GRAPH_PARAMS> |
|
inline void |
|
remove_vertex(typename DIRECTED_GRAPH::vertex_descriptor v, |
|
DIRECTED_GRAPH& g) |
|
{ return g.remove_vertex(v); } |
|
|
|
template <DIRECTED_GRAPH_PARAMS> |
|
inline std::pair<typename DIRECTED_GRAPH::edge_descriptor, bool> |
|
add_edge(typename DIRECTED_GRAPH::vertex_descriptor u, |
|
typename DIRECTED_GRAPH::vertex_descriptor v, |
|
DIRECTED_GRAPH& g) |
|
{ return g.add_edge(u, v); } |
|
|
|
template <DIRECTED_GRAPH_PARAMS> |
|
inline std::pair<typename DIRECTED_GRAPH::edge_descriptor, bool> |
|
add_edge(typename DIRECTED_GRAPH::vertex_descriptor u, |
|
typename DIRECTED_GRAPH::vertex_descriptor v, |
|
typename DIRECTED_GRAPH::edge_property_type const& p, |
|
DIRECTED_GRAPH& g) |
|
{ return g.add_edge(u, v, p); } |
|
|
|
template <DIRECTED_GRAPH_PARAMS> |
|
inline void remove_edge(typename DIRECTED_GRAPH::vertex_descriptor u, |
|
typename DIRECTED_GRAPH::vertex_descriptor v, |
|
DIRECTED_GRAPH& g) |
|
{ return g.remove_edge(u, v); } |
|
|
|
|
|
template <DIRECTED_GRAPH_PARAMS> |
|
inline void remove_edge(typename DIRECTED_GRAPH::edge_descriptor e, DIRECTED_GRAPH& g) |
|
{ return g.remove_edge(e); } |
|
|
|
template <DIRECTED_GRAPH_PARAMS> |
|
inline void remove_edge(typename DIRECTED_GRAPH::edge_iterator i, DIRECTED_GRAPH& g) |
|
{ return g.remove_edge(i); } |
|
|
|
template <DIRECTED_GRAPH_PARAMS, class Predicate> |
|
inline void remove_edge_if(Predicate pred, DIRECTED_GRAPH& g) |
|
{ return remove_edge_if(pred, g.impl()); } |
|
|
|
template <DIRECTED_GRAPH_PARAMS, class Predicate> |
|
inline void |
|
remove_out_edge_if(typename DIRECTED_GRAPH::vertex_descriptor v, |
|
Predicate pred, |
|
DIRECTED_GRAPH& g) |
|
{ return remove_out_edge_if(v, pred, g.impl()); } |
|
|
|
template <DIRECTED_GRAPH_PARAMS, class Predicate> |
|
inline void |
|
remove_in_edge_if(typename DIRECTED_GRAPH::vertex_descriptor v, |
|
Predicate pred, |
|
DIRECTED_GRAPH& g) |
|
{ return remove_in_edge_if(v, pred, g.impl()); } |
|
|
|
// Helper code for working with property maps |
|
namespace detail |
|
{ |
|
struct directed_graph_vertex_property_selector { |
|
template <class DirectedGraph, class Property, class Tag> |
|
struct bind_ { |
|
typedef typename DirectedGraph::graph_type Graph; |
|
typedef property_map<Graph, Tag> PropertyMap; |
|
typedef typename PropertyMap::type type; |
|
typedef typename PropertyMap::const_type const_type; |
|
}; |
|
}; |
|
|
|
struct directed_graph_edge_property_selector { |
|
template <class DirectedGraph, class Property, class Tag> |
|
struct bind_ { |
|
typedef typename DirectedGraph::graph_type Graph; |
|
typedef property_map<Graph, Tag> PropertyMap; |
|
typedef typename PropertyMap::type type; |
|
typedef typename PropertyMap::const_type const_type; |
|
}; |
|
}; |
|
} |
|
|
|
template <> |
|
struct vertex_property_selector<directed_graph_tag> |
|
{ typedef detail::directed_graph_vertex_property_selector type; }; |
|
|
|
template <> |
|
struct edge_property_selector<directed_graph_tag> |
|
{ typedef detail::directed_graph_edge_property_selector type; }; |
|
|
|
// PropertyGraph concepts |
|
template <DIRECTED_GRAPH_PARAMS, typename Property> |
|
inline typename property_map<DIRECTED_GRAPH, Property>::type |
|
get(Property p, DIRECTED_GRAPH& g) |
|
{ return get(p, g.impl()); } |
|
|
|
template <DIRECTED_GRAPH_PARAMS, typename Property> |
|
inline typename property_map<DIRECTED_GRAPH, Property>::const_type |
|
get(Property p, DIRECTED_GRAPH const& g) |
|
{ return get(p, g.impl()); } |
|
|
|
template <DIRECTED_GRAPH_PARAMS, typename Property, typename Key> |
|
inline typename property_traits< |
|
typename property_map< |
|
typename DIRECTED_GRAPH::graph_type, Property |
|
>::const_type |
|
>::value_type |
|
get(Property p, DIRECTED_GRAPH const& g, Key const& k) |
|
{ return get(p, g.impl(), k); } |
|
|
|
template <DIRECTED_GRAPH_PARAMS, typename Property, typename Key, typename Value> |
|
inline void put(Property p, DIRECTED_GRAPH& g, Key const& k, Value const& v) |
|
{ put(p, g.impl(), k, v); } |
|
|
|
template <DIRECTED_GRAPH_PARAMS, class Property> |
|
typename graph_property<DIRECTED_GRAPH, Property>::type& |
|
get_property(DIRECTED_GRAPH& g, Property p) |
|
{ return get_property(g.impl(), p); } |
|
|
|
template <DIRECTED_GRAPH_PARAMS, class Property> |
|
typename graph_property<DIRECTED_GRAPH, Property>::type const& |
|
get_property(DIRECTED_GRAPH const& g, Property p) |
|
{ return get_property(g.impl(), p); } |
|
|
|
template <DIRECTED_GRAPH_PARAMS, class Property, class Value> |
|
void |
|
set_property(DIRECTED_GRAPH& g, Property p, Value v) |
|
{ return set_property(g.impl(), p, v); } |
|
|
|
#ifndef BOOST_GRAPH_NO_BUNDLED_PROPERTIES |
|
|
|
template <DIRECTED_GRAPH_PARAMS, typename Type, typename Bundle> |
|
inline typename property_map<DIRECTED_GRAPH, Type Bundle::*>::type |
|
get(Type Bundle::* p, DIRECTED_GRAPH& g) { |
|
typedef typename property_map< |
|
DIRECTED_GRAPH, Type Bundle::* |
|
>::type return_type; |
|
return return_type(&g, p); |
|
} |
|
|
|
template <DIRECTED_GRAPH_PARAMS, typename Type, typename Bundle> |
|
inline typename property_map<DIRECTED_GRAPH, Type Bundle::*>::const_type |
|
get(Type Bundle::* p, DIRECTED_GRAPH const& g) { |
|
typedef typename property_map< |
|
DIRECTED_GRAPH, Type Bundle::* |
|
>::const_type return_type; |
|
return return_type(&g, p); |
|
} |
|
|
|
template <DIRECTED_GRAPH_PARAMS, typename Type, typename Bundle, typename Key> |
|
inline Type get(Type Bundle::* p, DIRECTED_GRAPH const& g, Key const& k) |
|
{ return get(p, g.impl(), k); } |
|
|
|
template <DIRECTED_GRAPH_PARAMS, typename Type, typename Bundle, typename Key, typename Value> |
|
inline void put(Type Bundle::* p, DIRECTED_GRAPH& g, Key const& k, Value const& v) |
|
{ put(p, g.impl(), k, v); } |
|
#endif |
|
|
|
// Vertex index management |
|
|
|
template <DIRECTED_GRAPH_PARAMS> |
|
inline typename DIRECTED_GRAPH::vertex_index_type |
|
get_vertex_index(typename DIRECTED_GRAPH::vertex_descriptor v, |
|
DIRECTED_GRAPH const& g) |
|
{ return get(vertex_index, g, v); } |
|
|
|
template <DIRECTED_GRAPH_PARAMS> |
|
typename DIRECTED_GRAPH::vertex_index_type |
|
max_vertex_index(DIRECTED_GRAPH const& g) |
|
{ return g.max_vertex_index(); } |
|
|
|
template <DIRECTED_GRAPH_PARAMS> |
|
inline void |
|
renumber_vertex_indices(DIRECTED_GRAPH& g) |
|
{ g.renumber_vertex_indices(); } |
|
|
|
template <DIRECTED_GRAPH_PARAMS> |
|
inline void |
|
remove_vertex_and_renumber_indices(typename DIRECTED_GRAPH::vertex_iterator i, |
|
DIRECTED_GRAPH& g) |
|
{ g.remove_vertex_and_renumber_indices(i); } |
|
|
|
// Edge index management |
|
template <DIRECTED_GRAPH_PARAMS> |
|
inline typename DIRECTED_GRAPH::edge_index_type |
|
get_edge_index(typename DIRECTED_GRAPH::edge_descriptor v, DIRECTED_GRAPH const& g) |
|
{ return get(edge_index, g, v); } |
|
|
|
template <DIRECTED_GRAPH_PARAMS> |
|
typename DIRECTED_GRAPH::edge_index_type |
|
max_edge_index(DIRECTED_GRAPH const& g) |
|
{ return g.max_edge_index(); } |
|
|
|
template <DIRECTED_GRAPH_PARAMS> |
|
inline void renumber_edge_indices(DIRECTED_GRAPH& g) |
|
{ g.renumber_edge_indices(); } |
|
|
|
template <DIRECTED_GRAPH_PARAMS> |
|
inline void |
|
remove_edge_and_renumber_indices(typename DIRECTED_GRAPH::edge_iterator i, |
|
DIRECTED_GRAPH& g) |
|
{ g.remove_edge_and_renumber_indices(i); } |
|
|
|
// Index management |
|
template <DIRECTED_GRAPH_PARAMS> |
|
inline void |
|
renumber_indices(DIRECTED_GRAPH& g) |
|
{ g.renumber_indices(); } |
|
|
|
// Mutability Traits |
|
template <DIRECTED_GRAPH_PARAMS> |
|
struct graph_mutability_traits<DIRECTED_GRAPH> { |
|
typedef mutable_property_graph_tag category; |
|
}; |
|
|
|
#undef DIRECTED_GRAPH_PARAMS |
|
#undef DIRECTED_GRAPH |
|
|
|
} /* namespace boost */ |
|
|
|
#endif
|
|
|