mirror of
https://github.com/boostorg/graph.git
synced 2026-01-31 08:12:14 +00:00
new name for filtered_edge_graph, added vertex predicate
[SVN r8856]
This commit is contained in:
Jeremy Siek
286
include/boost/graph/filtered_graph.hpp
Normal file
286
include/boost/graph/filtered_graph.hpp
Normal file
@@ -0,0 +1,286 @@
|
||||
//=======================================================================
|
||||
// Copyright 1997, 1998, 1999, 2000 University of Notre Dame.
|
||||
// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek
|
||||
//
|
||||
// This file is part of the Boost Graph Library
|
||||
//
|
||||
// You should have received a copy of the License Agreement for the
|
||||
// Boost Graph Library along with the software; see the file LICENSE.
|
||||
// If not, contact Office of Research, University of Notre Dame, Notre
|
||||
// Dame, IN 46556.
|
||||
//
|
||||
// Permission to modify the code and to distribute modified code is
|
||||
// granted, provided the text of this NOTICE is retained, a notice that
|
||||
// the code was modified is included with the above COPYRIGHT NOTICE and
|
||||
// with the COPYRIGHT NOTICE in the LICENSE file, and that the LICENSE
|
||||
// file is distributed with the modified code.
|
||||
//
|
||||
// LICENSOR MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED.
|
||||
// By way of example, but not limitation, Licensor MAKES NO
|
||||
// REPRESENTATIONS OR WARRANTIES OF MERCHANTABILITY OR FITNESS FOR ANY
|
||||
// PARTICULAR PURPOSE OR THAT THE USE OF THE LICENSED SOFTWARE COMPONENTS
|
||||
// OR DOCUMENTATION WILL NOT INFRINGE ANY PATENTS, COPYRIGHTS, TRADEMARKS
|
||||
// OR OTHER RIGHTS.
|
||||
//=======================================================================
|
||||
|
||||
#ifndef BOOST_FILTERED_GRAPH_HPP
|
||||
#define BOOST_FILTERED_GRAPH_HPP
|
||||
|
||||
#include <boost/pending/iterator_adaptors.hpp>
|
||||
#include <boost/graph/detail/adjacency_iterator.hpp>
|
||||
|
||||
namespace boost {
|
||||
|
||||
//===========================================================================
|
||||
// Some predicate classes.
|
||||
|
||||
struct keep_all {
|
||||
template <typename T>
|
||||
bool operator()(const T&) const { return true; }
|
||||
};
|
||||
|
||||
// Keep residual edges (used in maximum-flow algorithms).
|
||||
template <typename ResidualCapacityEdgeMap>
|
||||
struct is_residual_edge {
|
||||
is_residual_edge() { }
|
||||
is_residual_edge(ResidualCapacityEdgeMap rcap) : m_rcap(rcap) { }
|
||||
template <typename Edge>
|
||||
bool operator()(const Edge& e) const {
|
||||
return 0 < get(m_rcap, e);
|
||||
}
|
||||
ResidualCapacityEdgeMap m_rcap;
|
||||
};
|
||||
|
||||
namespace detail {
|
||||
template <typename EdgePredicate, typename VertexPredicate, typename Graph>
|
||||
struct out_edge_predicate {
|
||||
out_edge_predicate() { }
|
||||
out_edge_predicate(EdgePredicate ep, VertexPredicate vp,
|
||||
const Graph& g)
|
||||
: m_edge_pred(ep), m_vertex_pred(vp), m_g(&g) { }
|
||||
|
||||
template <typename Edge>
|
||||
bool operator()(const Edge& e) const {
|
||||
return m_edge_pred(e) && m_vertex_pred(target(e, *m_g));
|
||||
}
|
||||
EdgePredicate m_edge_pred;
|
||||
VertexPredicate m_vertex_pred;
|
||||
const Graph* m_g;
|
||||
};
|
||||
} // namespace detail
|
||||
|
||||
|
||||
//===========================================================================
|
||||
// Filtered Graph
|
||||
|
||||
template <typename Graph,
|
||||
typename EdgePredicate,
|
||||
typename VertexPredicate = keep_all>
|
||||
class filtered_graph {
|
||||
typedef graph_traits<Graph> Traits;
|
||||
typedef filtered_graph self;
|
||||
public:
|
||||
typedef detail::out_edge_predicate<EdgePredicate,
|
||||
VertexPredicate, self> OutEdgePred;
|
||||
|
||||
// Constructors
|
||||
filtered_graph(Graph& g, EdgePredicate ep)
|
||||
: m_g(g), m_edge_pred(ep) { }
|
||||
|
||||
filtered_graph(Graph& g, EdgePredicate ep, VertexPredicate vp)
|
||||
: m_g(g), m_edge_pred(ep), m_vertex_pred(vp) { }
|
||||
|
||||
// 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;
|
||||
|
||||
// IncidenceGraph requirements
|
||||
typedef typename filter_iterator<OutEdgePred,
|
||||
typename Traits::out_edge_iterator,
|
||||
boost::iterator<multi_pass_input_iterator_tag,
|
||||
edge_descriptor, std::ptrdiff_t,
|
||||
edge_descriptor*, edge_descriptor> >::type out_edge_iterator;
|
||||
typedef typename Traits::degree_size_type degree_size_type;
|
||||
|
||||
// AdjacencyGraph requirements
|
||||
typedef typename detail::adjacency_iterator<
|
||||
self, vertex_descriptor, out_edge_iterator,
|
||||
out_edge_iterator>::type adjacency_iterator;
|
||||
|
||||
// VertexListGraph requirements
|
||||
typedef typename filter_iterator<VertexPredicate,
|
||||
typename Traits::vertex_iterator,
|
||||
boost::iterator<multi_pass_input_iterator_tag,
|
||||
vertex_descriptor, std::ptrdiff_t,
|
||||
vertex_descriptor*, vertex_descriptor> >::type vertex_iterator;
|
||||
typedef typename Traits::vertices_size_type vertices_size_type;
|
||||
|
||||
// EdgeListGraph requirements
|
||||
typedef typename filter_iterator<EdgePredicate,
|
||||
typename Traits::edge_iterator,
|
||||
boost::iterator<multi_pass_input_iterator_tag,
|
||||
edge_descriptor, std::ptrdiff_t,
|
||||
edge_descriptor*, edge_descriptor> >::type edge_iterator;
|
||||
typedef typename Traits::edges_size_type edges_size_type;
|
||||
|
||||
typedef void in_edge_iterator;
|
||||
|
||||
typedef typename Graph::edge_property_type edge_property_type;
|
||||
typedef typename Graph::vertex_property_type vertex_property_type;
|
||||
typedef typename Graph::graph_tag graph_tag;
|
||||
|
||||
//private:
|
||||
Graph& m_g;
|
||||
EdgePredicate m_edge_pred;
|
||||
VertexPredicate m_vertex_pred;
|
||||
|
||||
typedef filter_iterator_policies<OutEdgePred,
|
||||
typename Traits::out_edge_iterator> out_edge_iter_policy;
|
||||
typedef filter_iterator_policies<EdgePredicate,
|
||||
typename Traits::edge_iterator> edge_iter_policy;
|
||||
};
|
||||
|
||||
//===========================================================================
|
||||
// Non-member functions for the Filtered Edge Graph
|
||||
|
||||
// Helper functions
|
||||
template <typename Graph, typename EdgePredicate>
|
||||
inline filtered_graph<Graph, EdgePredicate>
|
||||
make_filtered_graph(Graph& g, EdgePredicate ep) {
|
||||
return filtered_graph<Graph, EdgePredicate>(g, ep);
|
||||
}
|
||||
template <typename Graph, typename EdgePredicate, typename VertexPredicate>
|
||||
inline filtered_graph<Graph, EdgePredicate, VertexPredicate>
|
||||
make_filtered_graph(Graph& g, EdgePredicate ep, VertexPredicate vp) {
|
||||
return filtered_graph<Graph, EdgePredicate>(g, ep, vp);
|
||||
}
|
||||
|
||||
template <typename G, typename EP, typename VP>
|
||||
std::pair<typename graph_traits<G>::vertex_iterator,
|
||||
typename graph_traits<G>::vertex_iterator>
|
||||
vertices(const filtered_graph<G, EP, VP>& g) {
|
||||
return vertices(g.m_g);
|
||||
}
|
||||
|
||||
template <typename G, typename EP, typename VP>
|
||||
std::pair<typename filtered_graph<G, EP, VP>::edge_iterator,
|
||||
typename filtered_graph<G, EP, VP>::edge_iterator>
|
||||
edges(const filtered_graph<G, EP, VP>& g) {
|
||||
typedef filtered_graph<G, EP, VP> Graph;
|
||||
typedef typename Graph::edge_iter_policy Pol;
|
||||
typename graph_traits<G>::edge_iterator f, l;
|
||||
tie(f, l) = edges(g.m_g);
|
||||
typedef typename Graph::edge_iterator iter;
|
||||
return std::make_pair(iter(f, Pol(g.m_edge_pred, l)),
|
||||
iter(l, Pol(g.m_edge_pred, l)));
|
||||
}
|
||||
|
||||
template <typename G, typename EP, typename VP>
|
||||
typename graph_traits<G>::vertices_size_type
|
||||
num_vertices(const filtered_graph<G, EP, VP>& g) {
|
||||
return num_vertices(g);
|
||||
}
|
||||
|
||||
template <typename G, typename EP, typename VP>
|
||||
typename graph_traits<G>::edges_size_type
|
||||
num_edges(const filtered_graph<G, EP, VP>& g) {
|
||||
return num_edges(g);
|
||||
}
|
||||
|
||||
template <typename G, typename EP, typename VP>
|
||||
typename graph_traits<G>::vertex_descriptor
|
||||
source(typename graph_traits<G>::edge_descriptor e,
|
||||
const filtered_graph<G, EP, VP>& g)
|
||||
{
|
||||
return source(e, g.m_g);
|
||||
}
|
||||
|
||||
template <typename G, typename EP, typename VP>
|
||||
typename graph_traits<G>::vertex_descriptor
|
||||
target(typename graph_traits<G>::edge_descriptor e,
|
||||
const filtered_graph<G, EP, VP>& g)
|
||||
{
|
||||
return target(e, g.m_g);
|
||||
}
|
||||
|
||||
template <typename G, typename EP, typename VP>
|
||||
std::pair<typename filtered_graph<G, EP, VP>::out_edge_iterator,
|
||||
typename filtered_graph<G, EP, VP>::out_edge_iterator>
|
||||
out_edges(typename graph_traits<G>::vertex_descriptor u,
|
||||
const filtered_graph<G, EP, VP>& g)
|
||||
{
|
||||
typedef filtered_graph<G, EP, VP> Graph;
|
||||
typename Graph::OutEdgePred pred(g.m_edge_pred, g.m_vertex_pred, g);
|
||||
typedef typename Graph::out_edge_iter_policy Pol;
|
||||
typedef typename Graph::out_edge_iterator iter;
|
||||
typename graph_traits<G>::out_edge_iterator f, l;
|
||||
tie(f, l) = out_edges(u, g.m_g);
|
||||
return std::make_pair(iter(f, Pol(pred, l)), iter(l, Pol(pred, l)));
|
||||
}
|
||||
|
||||
template <typename G, typename EP, typename VP>
|
||||
typename graph_traits<G>::degree_size_type
|
||||
out_degree(typename graph_traits<G>::vertex_descriptor u,
|
||||
const filtered_graph<G, EP, VP>& g)
|
||||
{
|
||||
typename graph_traits<G>::degree_size_type n = 0;
|
||||
typename filtered_graph<G, EP, VP>::out_edge_iterator f, l;
|
||||
for (tie(f, l) = out_edges(u, g); f != l; ++f)
|
||||
++n;
|
||||
return n;
|
||||
}
|
||||
|
||||
template <typename G, typename EP, typename VP>
|
||||
std::pair<typename filtered_graph<G, EP, VP>::adjacency_iterator,
|
||||
typename filtered_graph<G, EP, VP>::adjacency_iterator>
|
||||
adjacent_vertices(typename graph_traits<G>::vertex_descriptor u,
|
||||
const filtered_graph<G, EP, VP>& g)
|
||||
{
|
||||
typedef filtered_graph<G, EP, VP> Graph;
|
||||
typedef typename Graph::adjacency_iterator adjacency_iterator;
|
||||
typename Graph::out_edge_iterator f, l;
|
||||
tie(f, l) = out_edges(u, g);
|
||||
return std::make_pair(adjacency_iterator(f, const_cast<Graph*>(&g)),
|
||||
adjacency_iterator(l, const_cast<Graph*>(&g)));
|
||||
}
|
||||
|
||||
template <typename G, typename EP, typename VP, typename Property>
|
||||
typename property_map<G, Property>::type
|
||||
get(Property p, filtered_graph<G, EP, VP>& g)
|
||||
{
|
||||
return get(p, g.m_g);
|
||||
}
|
||||
|
||||
template <typename G, typename EP, typename VP,typename Property>
|
||||
typename property_map<G, Property>::const_type
|
||||
get(Property p, const filtered_graph<G, EP, VP>& g)
|
||||
{
|
||||
return get(p, g.m_g);
|
||||
}
|
||||
|
||||
template <typename G, typename EP, typename VP, typename Property,
|
||||
typename Key>
|
||||
typename property_traits<
|
||||
typename property_map<G, Property>::const_type
|
||||
>::value_type
|
||||
get(Property p, const filtered_graph<G, EP, VP>& g, const Key& k)
|
||||
{
|
||||
return get(p, g.m_g, k);
|
||||
}
|
||||
|
||||
template <typename G, typename EP, typename VP, typename Property,
|
||||
typename Key, typename Value>
|
||||
void
|
||||
put(Property p, const filtered_graph<G, EP, VP>& g, const Key& k,
|
||||
const Value& val)
|
||||
{
|
||||
put(p, g.m_g, k, val);
|
||||
}
|
||||
|
||||
|
||||
} // namespace boost
|
||||
|
||||
|
||||
#endif // BOOST_FILTERED_GRAPH_HPP
|
||||
Reference in New Issue
Block a user