}
private:
+ vertex_node *raw(void) { return p; }
vertex_node *p;
u64a serial;
friend ue2_graph;
}
private:
+ edge_node *raw(void) { return p; }
edge_node *p;
u64a serial;
friend ue2_graph;
};
private:
- static
- vertex_node *raw(vertex_descriptor v) { return v.p; }
-
- static
- edge_node *raw(edge_descriptor e) { return e.p; }
-
/* Note: apparently, nested class templates cannot be fully specialised but
* they can be partially specialised. Sigh, ... */
template<typename BundleType, typename dummy = void>
if (main == main_end) {
return;
}
- std::tie(aux, aux_end) = out_edges_i(*main);
+ std::tie(aux, aux_end) = out_edges_impl(*main);
while (aux == aux_end) {
++main;
if (main == main_end) {
break;
}
- std::tie(aux, aux_end) = out_edges_i(*main);
+ std::tie(aux, aux_end) = out_edges_impl(*main);
}
}
edge_iterator() { }
if (main == main_end) {
break;
}
- std::tie(aux, aux_end) = out_edges_i(*main);
+ std::tie(aux, aux_end) = out_edges_impl(*main);
}
}
bool equal(const edge_iterator &other) const {
aux_base_iter_type aux_end;
};
-private:
- static
- std::pair<out_edge_iterator, out_edge_iterator>
- out_edges_i(vertex_descriptor v) {
- return {out_edge_iterator(raw(v)->out_edge_list.begin()),
- out_edge_iterator(raw(v)->out_edge_list.end())};
- }
-
public:
static
vertex_descriptor null_vertex() { return vertex_descriptor(); }
- friend
- vertex_descriptor add_vertex(Graph &g) {
- vertex_node *v = new vertex_node(g.new_serial());
- v->props.index = g.next_vertex_index++;
- g.vertices_list.push_back(*v);
+ vertex_descriptor add_vertex_impl() {
+ vertex_node *v = new vertex_node(new_serial());
+ v->props.index = next_vertex_index++;
+ vertices_list.push_back(*v);
return vertex_descriptor(v);
}
- friend
- void remove_vertex(vertex_descriptor v, Graph &g) {
- vertex_node *vv = Graph::raw(v);
+ void remove_vertex_impl(vertex_descriptor v) {
+ vertex_node *vv = v.raw();
assert(vv->in_edge_list.empty());
assert(vv->out_edge_list.empty());
- g.vertices_list.erase_and_dispose(g.vertices_list.iterator_to(*vv),
- delete_disposer());
+ vertices_list.erase_and_dispose(vertices_list.iterator_to(*vv),
+ delete_disposer());
}
- friend
- void clear_in_edges(vertex_descriptor v, Graph &g) {
- g.graph_edge_count -= Graph::raw(v)->in_edge_list.size();
- Graph::raw(v)->in_edge_list.clear_and_dispose(in_edge_disposer());
- }
-
- friend
- void clear_out_edges(vertex_descriptor v, Graph &g) {
- g.graph_edge_count -= Graph::raw(v)->out_edge_list.size();
- Graph::raw(v)->out_edge_list.clear_and_dispose(out_edge_disposer());
+ void clear_in_edges_impl(vertex_descriptor v) {
+ graph_edge_count -= v.raw()->in_edge_list.size();
+ v.raw()->in_edge_list.clear_and_dispose(in_edge_disposer());
}
- friend
- void clear_vertex(vertex_descriptor v, Graph &g) {
- clear_in_edges(v, g);
- clear_out_edges(v, g);
+ void clear_out_edges_impl(vertex_descriptor v) {
+ graph_edge_count -= v.raw()->out_edge_list.size();
+ v.raw()->out_edge_list.clear_and_dispose(out_edge_disposer());
}
/* IncidenceGraph concept functions */
- friend
- vertex_descriptor source(edge_descriptor e, const Graph &) {
- return vertex_descriptor(Graph::raw(e)->source);
+ static
+ vertex_descriptor source_impl(edge_descriptor e) {
+ return vertex_descriptor(e.raw()->source);
}
- friend
- vertex_descriptor target(edge_descriptor e, const Graph &) {
- return vertex_descriptor(Graph::raw(e)->target);
+ static
+ vertex_descriptor target_impl(edge_descriptor e) {
+ return vertex_descriptor(e.raw()->target);
}
- friend
- degree_size_type out_degree(vertex_descriptor v, const Graph &) {
- return Graph::raw(v)->out_edge_list.size();
+ static
+ degree_size_type out_degree_impl(vertex_descriptor v) {
+ return v.raw()->out_edge_list.size();
}
- friend
+ static
std::pair<out_edge_iterator, out_edge_iterator>
- out_edges(vertex_descriptor v, const Graph &) {
- return Graph::out_edges_i(v);
+ out_edges_impl(vertex_descriptor v) {
+ return {out_edge_iterator(v.raw()->out_edge_list.begin()),
+ out_edge_iterator(v.raw()->out_edge_list.end())};
}
/* BidirectionalGraph concept functions */
- friend
- degree_size_type in_degree(vertex_descriptor v, const Graph &) {
- return Graph::raw(v)->in_edge_list.size();
+ static
+ degree_size_type in_degree_impl(vertex_descriptor v) {
+ return v.raw()->in_edge_list.size();
}
- friend
+ static
std::pair<in_edge_iterator, in_edge_iterator>
- in_edges(vertex_descriptor v, const Graph &) {
- return {in_edge_iterator(Graph::raw(v)->in_edge_list.begin()),
- in_edge_iterator(Graph::raw(v)->in_edge_list.end())};
+ in_edges_impl(vertex_descriptor v) {
+ return {in_edge_iterator(v.raw()->in_edge_list.begin()),
+ in_edge_iterator(v.raw()->in_edge_list.end())};
}
/* Note: this is defined so that self loops are counted twice - which may or
* may not be what you want. Actually, you probably don't want this at
* all. */
- friend
- degree_size_type degree(vertex_descriptor v, const Graph &g) {
- return in_degree(v, g) + out_degree(v, g);
+ static
+ degree_size_type degree_impl(vertex_descriptor v) {
+ return in_degree_impl(v) + out_degree_impl(v);
}
/* AdjacencyList concept functions */
- friend
+ static
std::pair<adjacency_iterator, adjacency_iterator>
- adjacent_vertices(vertex_descriptor v, const Graph &g) {
- auto out_edge_its = out_edges(v, g);
+ adjacent_vertices_impl(vertex_descriptor v) {
+ auto out_edge_its = out_edges_impl(v);
return {adjacency_iterator(out_edge_its.first),
adjacency_iterator(out_edge_its.second)};
}
/* AdjacencyMatrix concept functions
* (Note: complexity guarantee is not met) */
- friend
- std::pair<edge_descriptor, bool> edge(vertex_descriptor u,
- vertex_descriptor v, const Graph &g) {
- if (in_degree(v, g) < out_degree(u, g)) {
- for (const edge_descriptor &e : in_edges_range(v, g)) {
- if (source(e, g) == u) {
+ std::pair<edge_descriptor, bool> edge_impl(vertex_descriptor u,
+ vertex_descriptor v) const {
+ if (in_degree_impl(v) < out_degree_impl(u)) {
+ for (const edge_descriptor &e : in_edges_range(v, *this)) {
+ if (source_impl(e) == u) {
return {e, true};
}
}
} else {
- for (const edge_descriptor &e : out_edges_range(u, g)) {
- if (target(e, g) == v) {
+ for (const edge_descriptor &e : out_edges_range(u, *this)) {
+ if (target_impl(e) == v) {
return {e, true};
}
}
static
edge_descriptor null_edge() { return edge_descriptor(); }
- friend
+ static
std::pair<inv_adjacency_iterator, inv_adjacency_iterator>
- inv_adjacent_vertices(vertex_descriptor v, const Graph &g) {
- auto in_edge_its = in_edges(v, g);
+ inv_adjacent_vertices_impl(vertex_descriptor v) {
+ auto in_edge_its = in_edges_impl(v);
return {inv_adjacency_iterator(in_edge_its.first),
inv_adjacency_iterator(in_edge_its.second)};
}
/* MutableGraph concept functions */
- friend
std::pair<edge_descriptor, bool>
- add_edge(vertex_descriptor u, vertex_descriptor v, Graph &g) {
+ add_edge_impl(vertex_descriptor u, vertex_descriptor v) {
bool added = true; /* we always allow parallel edges */
- edge_node *e = new edge_node(g.new_serial());
- e->source = Graph::raw(u);
- e->target = Graph::raw(v);
- e->props.index = g.next_edge_index++;
+ edge_node *e = new edge_node(new_serial());
+ e->source = u.raw();
+ e->target = v.raw();
+ e->props.index = next_edge_index++;
- Graph::raw(u)->out_edge_list.push_back(*e);
- Graph::raw(v)->in_edge_list.push_back(*e);
+ u.raw()->out_edge_list.push_back(*e);
+ v.raw()->in_edge_list.push_back(*e);
- g.graph_edge_count++;
+ graph_edge_count++;
return {edge_descriptor(e), added};
}
- friend
- void remove_edge(edge_descriptor e, Graph &g) {
- g.graph_edge_count--;
+ void remove_edge_impl(edge_descriptor e) {
+ graph_edge_count--;
- vertex_node *u = Graph::raw(source(e, g));
- vertex_node *v = Graph::raw(target(e, g));
+ vertex_node *u = e.raw()->source;
+ vertex_node *v = e.raw()->target;
- v->in_edge_list.erase(v->in_edge_list.iterator_to(*Graph::raw(e)));
- u->out_edge_list.erase(u->out_edge_list.iterator_to(*Graph::raw(e)));
+ v->in_edge_list.erase(v->in_edge_list.iterator_to(*e.raw()));
+ u->out_edge_list.erase(u->out_edge_list.iterator_to(*e.raw()));
- delete Graph::raw(e);
- }
-
- template<class Iter>
- friend
- void remove_edge(Iter it, Graph &g) {
- remove_edge(*it, g);
+ delete e.raw();
}
template<class Predicate>
- friend
- void remove_out_edge_if(vertex_descriptor v, Predicate pred, Graph &g) {
+ void remove_out_edge_if_impl(vertex_descriptor v, Predicate pred) {
out_edge_iterator it, ite;
- std::tie(it, ite) = out_edges(v, g);
+ std::tie(it, ite) = out_edges_impl(v);
while (it != ite) {
auto jt = it;
++it;
if (pred(*jt)) {
- remove_edge(*jt, g);
+ this->remove_edge_impl(*jt);
}
}
}
template<class Predicate>
- friend
- void remove_in_edge_if(vertex_descriptor v, Predicate pred, Graph &g) {
+ void remove_in_edge_if_impl(vertex_descriptor v, Predicate pred) {
in_edge_iterator it, ite;
- std::tie(it, ite) = in_edges(v, g);
+ std::tie(it, ite) = in_edges_impl(v);
while (it != ite) {
auto jt = it;
++it;
if (pred(*jt)) {
- remove_edge(*jt, g);
+ remove_edge_impl(*jt);
}
}
}
template<class Predicate>
- friend
- void remove_edge_if(Predicate pred, Graph &g) {
+ void remove_edge_if_impl(Predicate pred) {
edge_iterator it, ite;
- std::tie(it, ite) = edges(g);
+ std::tie(it, ite) = edges_impl();
while (it != ite) {
auto jt = it;
++it;
if (pred(*jt)) {
- remove_edge(*jt, g);
+ remove_edge_impl(*jt);
}
}
}
private:
/* GCC 4.8 has bugs with lambdas in templated friend functions, so: */
struct source_match {
- source_match(const vertex_descriptor &uu, const Graph &gg)
- : u(uu), g(gg) { }
- bool operator()(edge_descriptor e) const { return source(e, g) == u; }
+ explicit source_match(const vertex_descriptor &uu) : u(uu) { }
+ bool operator()(edge_descriptor e) const { return source_impl(e) == u; }
const vertex_descriptor &u;
- const Graph &g;
};
struct target_match {
- target_match(const vertex_descriptor &vv, const Graph &gg)
- : v(vv), g(gg) { }
- bool operator()(edge_descriptor e) const { return target(e, g) == v; }
+ explicit target_match(const vertex_descriptor &vv) : v(vv) { }
+ bool operator()(edge_descriptor e) const { return target_impl(e) == v; }
const vertex_descriptor &v;
- const Graph &g;
};
public:
-
/* Note: (u,v) variant needs to remove all (parallel) edges between (u,v).
*
* The edge_descriptor version should be strongly preferred if the
* edge_descriptor is available.
*/
- friend
- void remove_edge(const vertex_descriptor &u,
- const vertex_descriptor &v,
- Graph &g) {
- if (in_degree(v, g) < out_degree(u, g)) {
- remove_in_edge_if(v, source_match(u, g), g);
+ void remove_edge_impl(const vertex_descriptor &u,
+ const vertex_descriptor &v) {
+ if (in_degree_impl(v) < out_degree_impl(u)) {
+ remove_in_edge_if_impl(v, source_match(u));
} else {
- remove_out_edge_if(u, target_match(v, g), g);
+ remove_out_edge_if_impl(u, target_match(v));
}
}
/* VertexListGraph concept functions */
-
- friend
- vertices_size_type num_vertices(const Graph &g) {
- return g.vertices_list.size();
+ vertices_size_type num_vertices_impl() const {
+ return vertices_list.size();
}
- friend
- std::pair<vertex_iterator, vertex_iterator> vertices(const Graph &g) {
- return {vertex_iterator(g.vertices_list.begin()),
- vertex_iterator(g.vertices_list.end())};
+ std::pair<vertex_iterator, vertex_iterator> vertices_impl() const {
+ return {vertex_iterator(vertices_list.begin()),
+ vertex_iterator(vertices_list.end())};
}
/* EdgeListGraph concept functions (aside from those in IncidenceGraph) */
- friend
- edges_size_type num_edges(const Graph &g) {
- return g.graph_edge_count;
+ edges_size_type num_edges_impl() const {
+ return graph_edge_count;
}
- friend
- std::pair<edge_iterator, edge_iterator> edges(const Graph &g) {
+ std::pair<edge_iterator, edge_iterator> edges_impl() const {
vertex_iterator vi, ve;
- std::tie(vi, ve) = vertices(g);
+ std::tie(vi, ve) = vertices_impl();
return {edge_iterator(vi, ve), edge_iterator(ve, ve)};
}
/* bundled properties functions */
vertex_property_type &operator[](vertex_descriptor v) {
- return raw(v)->props;
+ return v.raw()->props;
}
const vertex_property_type &operator[](vertex_descriptor v) const {
- return raw(v)->props;
+ return v.raw()->props;
}
edge_property_type &operator[](edge_descriptor e) {
- return raw(e)->props;
+ return e.raw()->props;
}
const edge_property_type &operator[](edge_descriptor e) const {
- return raw(e)->props;
+ return e.raw()->props;
}
/* PropertyGraph concept functions & helpers */
prop_map(value_type P_of::*m_in) : member(m_in) { }
reference operator[](key_type k) const {
- return Graph::raw(k)->props.*member;
+ return k.raw()->props.*member;
}
reference operator()(key_type k) const { return (*this)[k]; }
typedef typename boost::lvalue_property_map_tag category;
reference operator[](key_type k) const {
- return Graph::raw(k)->props;
+ return k.raw()->props;
}
reference operator()(key_type k) const { return (*this)[k]; }
};
* rather than using the index in vp. i.e., except for in rare coincidences:
* g[add_vertex(g, vp)].index != vp.index
*/
- friend
- vertex_descriptor add_vertex(const VertexPropertyType &vp, Graph &g) {
- vertex_descriptor v = add_vertex(g);
- auto i = g[v].index;
- g[v] = vp;
- g[v].index = i;
+ vertex_descriptor add_vertex_impl(const VertexPropertyType &vp) {
+ vertex_descriptor v = add_vertex_impl();
+ auto i = (*this)[v].index;
+ (*this)[v] = vp;
+ (*this)[v].index = i;
return v;
}
* rather than using the index in ep. i.e., except for in rare coincidences:
* g[add_edge(u, v, g, ep)].index != ep.index
*/
- friend
std::pair<edge_descriptor, bool>
- add_edge(vertex_descriptor u, vertex_descriptor v,
- const EdgePropertyType &ep, Graph &g) {
- auto e = add_edge(u, v, g);
- auto i = g[e.first].index;
- g[e.first] = ep;
- g[e.first].index = i;
+ add_edge_impl(vertex_descriptor u, vertex_descriptor v,
+ const EdgePropertyType &ep) {
+ auto e = add_edge_impl(u, v);
+ auto i = (*this)[e.first].index;
+ (*this)[e.first] = ep;
+ (*this)[e.first].index = i;
return e;
}
/* End MutablePropertyGraph */
/** Pack the edge index into a contiguous range [ 0, num_edges(g) ). */
- friend
- void renumber_edges(Graph &g) {
- g.next_edge_index = 0;
- for (const auto &e : edges_range(g)) {
- g[e].index = g.next_edge_index++;
+ void renumber_edges_impl() {
+ next_edge_index = 0;
+ edge_iterator it;
+ edge_iterator ite;
+ for (std::tie(it, ite) = edges_impl(); it != ite; ++it) {
+ (*this)[*it].index = next_edge_index++;
}
}
/** Pack the vertex index into a contiguous range [ 0, num_vertices(g) ).
* Vertices with indices less than N_SPECIAL_VERTICES are not renumbered.
*/
- friend
- void renumber_vertices(Graph &g) {
+ void renumber_vertices_impl() {
DEBUG_PRINTF("renumbering above %zu\n", Graph::N_SPECIAL_VERTICES);
- g.next_vertex_index = Graph::N_SPECIAL_VERTICES;
- for (const auto &v : vertices_range(g)) {
- if (g[v].index < Graph::N_SPECIAL_VERTICES) {
+ next_vertex_index = Graph::N_SPECIAL_VERTICES;
+ vertex_iterator it;
+ vertex_iterator ite;
+ for (std::tie(it, ite) = vertices_impl(); it != ite; ++it) {
+ if ((*this)[*it].index < Graph::N_SPECIAL_VERTICES) {
continue;
}
- g[v].index = g.next_vertex_index++;
+ (*this)[*it].index = next_vertex_index++;
}
}
/** Returns what the next allocated vertex index will be. This is an upper
* on the values of index for vertices (vertex removal means that there may
* be gaps). */
- friend
- vertices_size_type vertex_index_upper_bound(const Graph &g) {
- return g.next_vertex_index;
+ vertices_size_type vertex_index_upper_bound_impl() const {
+ return next_vertex_index;
}
/** Returns what the next allocated edge index will be. This is an upper on
* the values of index for edges (edge removal means that there may be
* gaps). */
- friend
- vertices_size_type edge_index_upper_bound(const Graph &g) {
- return g.next_edge_index;
+ vertices_size_type edge_index_upper_bound_impl() const {
+ return next_edge_index;
}
using directed_category = boost::directed_tag;
}
};
+template<typename Graph>
+typename std::enable_if<
+ std::is_base_of<ue2::graph_detail::graph_base, Graph>::value,
+ typename Graph::vertex_descriptor>::type
+add_vertex(Graph &g) {
+ return g.add_vertex_impl();
+}
+
+template<typename Graph>
+typename std::enable_if<
+ std::is_base_of<ue2::graph_detail::graph_base, Graph>::value>::type
+remove_vertex(typename Graph::vertex_descriptor v, Graph &g) {
+ g.remove_vertex_impl(v);
+}
+
+template<typename Graph>
+typename std::enable_if<
+ std::is_base_of<ue2::graph_detail::graph_base, Graph>::value>::type
+clear_in_edges(typename Graph::vertex_descriptor v, Graph &g) {
+ g.clear_in_edges_impl(v);
+}
+
+template<typename Graph>
+typename std::enable_if<
+ std::is_base_of<ue2::graph_detail::graph_base, Graph>::value>::type
+clear_out_edges(typename Graph::vertex_descriptor v, Graph &g) {
+ g.clear_out_edges_impl(v);
+}
+
+template<typename Graph>
+typename std::enable_if<
+ std::is_base_of<ue2::graph_detail::graph_base, Graph>::value>::type
+clear_vertex(typename Graph::vertex_descriptor v, Graph &g) {
+ g.clear_in_edges_impl(v);
+ g.clear_out_edges_impl(v);
+}
+
+template<typename Graph>
+typename std::enable_if<
+ std::is_base_of<ue2::graph_detail::graph_base, Graph>::value,
+ typename Graph::vertex_descriptor>::type
+source(typename Graph::edge_descriptor e, const Graph &) {
+ return Graph::source_impl(e);
+}
+
+template<typename Graph>
+typename std::enable_if<
+ std::is_base_of<ue2::graph_detail::graph_base, Graph>::value,
+ typename Graph::vertex_descriptor>::type
+target(typename Graph::edge_descriptor e, const Graph &) {
+ return Graph::target_impl(e);
+}
+
+template<typename Graph>
+typename std::enable_if<
+ std::is_base_of<ue2::graph_detail::graph_base, Graph>::value,
+ typename Graph::degree_size_type>::type
+out_degree(typename Graph::vertex_descriptor v, const Graph &) {
+ return Graph::out_degree_impl(v);
+}
+
+template<typename Graph>
+typename std::enable_if<
+ std::is_base_of<ue2::graph_detail::graph_base, Graph>::value,
+ std::pair<typename Graph::out_edge_iterator,
+ typename Graph::out_edge_iterator>>::type
+out_edges(typename Graph::vertex_descriptor v, const Graph &) {
+ return Graph::out_edges_impl(v);
+}
+
+template<typename Graph>
+typename std::enable_if<
+ std::is_base_of<ue2::graph_detail::graph_base, Graph>::value,
+ typename Graph::degree_size_type>::type
+in_degree(typename Graph::vertex_descriptor v, const Graph &) {
+ return Graph::in_degree_impl(v);
+}
+
+template<typename Graph>
+typename std::enable_if<
+ std::is_base_of<ue2::graph_detail::graph_base, Graph>::value,
+ std::pair<typename Graph::in_edge_iterator,
+ typename Graph::in_edge_iterator>>::type
+in_edges(typename Graph::vertex_descriptor v, const Graph &) {
+ return Graph::in_edges_impl(v);
+}
+
+template<typename Graph>
+typename std::enable_if<
+ std::is_base_of<ue2::graph_detail::graph_base, Graph>::value,
+ typename Graph::degree_size_type>::type
+degree(typename Graph::vertex_descriptor v, const Graph &) {
+ return Graph::degree_impl(v);
+}
+
+template<typename Graph>
+typename std::enable_if<
+ std::is_base_of<ue2::graph_detail::graph_base, Graph>::value,
+ std::pair<typename Graph::adjacency_iterator,
+ typename Graph::adjacency_iterator>>::type
+adjacent_vertices(typename Graph::vertex_descriptor v, const Graph &) {
+ return Graph::adjacent_vertices_impl(v);
+}
+
+template<typename Graph>
+typename std::enable_if<
+ std::is_base_of<ue2::graph_detail::graph_base, Graph>::value,
+ std::pair<typename Graph::edge_descriptor, bool>>::type
+edge(typename Graph::vertex_descriptor u, typename Graph::vertex_descriptor v,
+ const Graph &g) {
+ return g.edge_impl(u, v);
+}
+
+template<typename Graph>
+typename std::enable_if<
+ std::is_base_of<ue2::graph_detail::graph_base, Graph>::value,
+ std::pair<typename Graph::inv_adjacency_iterator,
+ typename Graph::inv_adjacency_iterator>>::type
+inv_adjacent_vertices(typename Graph::vertex_descriptor v, const Graph &) {
+ return Graph::inv_adjacent_vertices_impl(v);
+}
+
+template<typename Graph>
+typename std::enable_if<
+ std::is_base_of<ue2::graph_detail::graph_base, Graph>::value,
+ std::pair<typename Graph::edge_descriptor, bool>>::type
+add_edge(typename Graph::vertex_descriptor u,
+ typename Graph::vertex_descriptor v, Graph &g) {
+ return g.add_edge_impl(u, v);
+}
+
+template<typename Graph>
+typename std::enable_if<
+ std::is_base_of<ue2::graph_detail::graph_base, Graph>::value>::type
+remove_edge(typename Graph::edge_descriptor e, Graph &g) {
+ g.remove_edge_impl(e);
+}
+
+template<typename Graph, typename Iter>
+typename std::enable_if<
+ !std::is_convertible<Iter, typename Graph::edge_descriptor>::value
+ && std::is_base_of<ue2::graph_detail::graph_base, Graph>::value>::type
+remove_edge(Iter it, Graph &g) {
+ g.remove_edge_impl(*it);
+}
+
+template<typename Graph, typename Predicate>
+typename std::enable_if<
+ std::is_base_of<ue2::graph_detail::graph_base, Graph>::value>::type
+remove_out_edge_if(typename Graph::vertex_descriptor v, Predicate pred,
+ Graph &g) {
+ g.remove_out_edge_if_impl(v, pred);
+}
+
+template<typename Graph, typename Predicate>
+typename std::enable_if<
+ std::is_base_of<ue2::graph_detail::graph_base, Graph>::value>::type
+remove_in_edge_if(typename Graph::vertex_descriptor v, Predicate pred,
+ Graph &g) {
+ g.remove_in_edge_if_impl(v, pred);
+}
+
+template<typename Graph, typename Predicate>
+typename std::enable_if<
+ std::is_base_of<ue2::graph_detail::graph_base, Graph>::value>::type
+remove_edge_if(Predicate pred, Graph &g) {
+ g.remove_edge_if_impl(pred);
+}
+
+template<typename Graph>
+typename std::enable_if<
+ std::is_base_of<ue2::graph_detail::graph_base, Graph>::value>::type
+remove_edge(const typename Graph::vertex_descriptor &u,
+ const typename Graph::vertex_descriptor &v, Graph &g) {
+ g.remove_edge_impl(u, v);
+}
+
+template<typename Graph>
+typename std::enable_if<
+ std::is_base_of<ue2::graph_detail::graph_base, Graph>::value,
+ typename Graph::vertices_size_type>::type
+num_vertices(const Graph &g) {
+ return g.num_vertices_impl();
+}
+
+template<typename Graph>
+typename std::enable_if<
+ std::is_base_of<ue2::graph_detail::graph_base, Graph>::value,
+ std::pair<typename Graph::vertex_iterator,
+ typename Graph::vertex_iterator>>::type
+vertices(const Graph &g) {
+ return g.vertices_impl();
+}
+
+template<typename Graph>
+typename std::enable_if<
+ std::is_base_of<ue2::graph_detail::graph_base, Graph>::value,
+ typename Graph::edges_size_type>::type
+num_edges(const Graph &g) {
+ return g.num_edges_impl();
+}
+
+template<typename Graph>
+typename std::enable_if<
+ std::is_base_of<ue2::graph_detail::graph_base, Graph>::value,
+ std::pair<typename Graph::edge_iterator,
+ typename Graph::edge_iterator>>::type
+edges(const Graph &g) {
+ return g.edges_impl();
+}
+
+template<typename Graph>
+typename std::enable_if<
+ std::is_base_of<ue2::graph_detail::graph_base, Graph>::value,
+ typename Graph::vertex_descriptor>::type
+add_vertex(const typename Graph::vertex_property_type &vp, Graph &g) {
+ return g.add_vertex_impl(vp);
+}
+
+template<typename Graph>
+typename std::enable_if<
+ std::is_base_of<ue2::graph_detail::graph_base, Graph>::value,
+ std::pair<typename Graph::edge_descriptor, bool>>::type
+add_edge(typename Graph::vertex_descriptor u,
+ typename Graph::vertex_descriptor v,
+ const typename Graph::edge_property_type &ep, Graph &g) {
+ return g.add_edge_impl(u, v, ep);
+}
+
+template<typename Graph>
+typename std::enable_if<
+ std::is_base_of<ue2::graph_detail::graph_base, Graph>::value>::type
+renumber_edges(Graph &g) {
+ g.renumber_edges_impl();
+}
+
+template<typename Graph>
+typename std::enable_if<
+ std::is_base_of<ue2::graph_detail::graph_base, Graph>::value>::type
+renumber_vertices(Graph &g) {
+ g.renumber_vertices_impl();
+}
+
+template<typename Graph>
+typename std::enable_if<
+ std::is_base_of<ue2::graph_detail::graph_base, Graph>::value,
+ typename Graph::vertices_size_type>::type
+vertex_index_upper_bound(const Graph &g) {
+ return g.vertex_index_upper_bound_impl();
+}
+
+template<typename Graph>
+typename std::enable_if<
+ std::is_base_of<ue2::graph_detail::graph_base, Graph>::value,
+ typename Graph::edges_size_type>::type
+edge_index_upper_bound(const Graph &g) {
+ return g.edge_index_upper_bound_impl();
+}
+
using boost::vertex_index;
using boost::edge_index;
projects / thirdparty / vectorscan.git / commitdiff
