1607 lines
67 KiB
C++
1607 lines
67 KiB
C++
// Copyright 2005-2009 The Trustees of Indiana University.
|
|
|
|
// 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)
|
|
|
|
// Authors: Jeremiah Willcock
|
|
// Douglas Gregor
|
|
// Andrew Lumsdaine
|
|
|
|
// Compressed sparse row graph type
|
|
|
|
#ifndef BOOST_GRAPH_COMPRESSED_SPARSE_ROW_GRAPH_HPP
|
|
#define BOOST_GRAPH_COMPRESSED_SPARSE_ROW_GRAPH_HPP
|
|
|
|
#include <vector>
|
|
#include <utility>
|
|
#include <algorithm>
|
|
#include <climits>
|
|
#include <boost/assert.hpp>
|
|
#include <iterator>
|
|
#if 0
|
|
#include <iostream> // For some debugging code below
|
|
#endif
|
|
#include <boost/graph/graph_traits.hpp>
|
|
#include <boost/graph/properties.hpp>
|
|
#include <boost/graph/filtered_graph.hpp> // For keep_all
|
|
#include <boost/graph/detail/indexed_properties.hpp>
|
|
#include <boost/graph/detail/compressed_sparse_row_struct.hpp>
|
|
#include <boost/graph/iteration_macros.hpp>
|
|
#include <boost/iterator/counting_iterator.hpp>
|
|
#include <boost/iterator/reverse_iterator.hpp>
|
|
#include <boost/iterator/zip_iterator.hpp>
|
|
#include <boost/iterator/transform_iterator.hpp>
|
|
#include <boost/tuple/tuple.hpp>
|
|
#include <boost/property_map/property_map.hpp>
|
|
#include <boost/integer.hpp>
|
|
#include <boost/iterator/iterator_facade.hpp>
|
|
#include <boost/mpl/if.hpp>
|
|
#include <boost/utility/enable_if.hpp>
|
|
#include <boost/graph/graph_selectors.hpp>
|
|
#include <boost/graph/detail/is_distributed_selector.hpp>
|
|
#include <boost/graph/properties.hpp>
|
|
#include <boost/static_assert.hpp>
|
|
#include <boost/functional/hash.hpp>
|
|
#include <boost/next_prior.hpp>
|
|
#include <boost/property_map/transform_value_property_map.hpp>
|
|
#include <boost/mpl/print.hpp>
|
|
|
|
namespace boost {
|
|
|
|
// A tag type indicating that the graph in question is a compressed
|
|
// sparse row graph. This is an internal detail of the BGL.
|
|
struct csr_graph_tag;
|
|
|
|
// A type (edges_are_sorted_t) and a value (edges_are_sorted) used to indicate
|
|
// that the edge list passed into the CSR graph is already sorted by source
|
|
// vertex.
|
|
enum edges_are_sorted_t {edges_are_sorted};
|
|
|
|
// A type (edges_are_sorted_global_t) and a value (edges_are_sorted_global)
|
|
// used to indicate that the edge list passed into the CSR graph is already
|
|
// sorted by source vertex.
|
|
enum edges_are_sorted_global_t {edges_are_sorted_global};
|
|
|
|
// A type (edges_are_unsorted_t) and a value (edges_are_unsorted) used to
|
|
// indicate that the edge list passed into the CSR graph is not sorted by
|
|
// source vertex. This version caches the edge information in memory, and thus
|
|
// requires only a single pass over the input data.
|
|
enum edges_are_unsorted_t {edges_are_unsorted};
|
|
|
|
// A type (edges_are_unsorted_multi_pass_t) and a value
|
|
// (edges_are_unsorted_multi_pass) used to indicate that the edge list passed
|
|
// into the CSR graph is not sorted by source vertex. This version uses less
|
|
// memory but requires multi-pass capability on the iterators.
|
|
enum edges_are_unsorted_multi_pass_t {edges_are_unsorted_multi_pass};
|
|
|
|
// A type (edges_are_unsorted_multi_pass_global_t) and a value
|
|
// (edges_are_unsorted_multi_pass_global) used to indicate that the edge list
|
|
// passed into the CSR graph is not sorted by source vertex. This version uses
|
|
// less memory but requires multi-pass capability on the iterators. The
|
|
// global mapping and filtering is done here because it is often faster and it
|
|
// greatly simplifies handling of edge properties.
|
|
enum edges_are_unsorted_multi_pass_global_t {edges_are_unsorted_multi_pass_global};
|
|
|
|
// A type (construct_inplace_from_sources_and_targets_t) and a value
|
|
// (construct_inplace_from_sources_and_targets) used to indicate that mutable
|
|
// vectors of sources and targets (and possibly edge properties) are being used
|
|
// to construct the CSR graph. These vectors are sorted in-place and then the
|
|
// targets and properties are swapped into the graph data structure.
|
|
enum construct_inplace_from_sources_and_targets_t {construct_inplace_from_sources_and_targets};
|
|
|
|
// A type (construct_inplace_from_sources_and_targets_global_t) and a value
|
|
// (construct_inplace_from_sources_and_targets_global) used to indicate that
|
|
// mutable vectors of sources and targets (and possibly edge properties) are
|
|
// being used to construct the CSR graph. These vectors are sorted in-place
|
|
// and then the targets and properties are swapped into the graph data
|
|
// structure. It is assumed that global indices (for distributed CSR) are
|
|
// used, and a map is required to convert those to local indices. This
|
|
// constructor is intended for internal use by the various CSR graphs
|
|
// (sequential and distributed).
|
|
enum construct_inplace_from_sources_and_targets_global_t {construct_inplace_from_sources_and_targets_global};
|
|
|
|
// A type (edges_are_unsorted_global_t) and a value (edges_are_unsorted_global)
|
|
// used to indicate that the edge list passed into the CSR graph is not sorted
|
|
// by source vertex. The data is also stored using global vertex indices, and
|
|
// must be filtered to choose only local vertices. This constructor caches the
|
|
// edge information in memory, and thus requires only a single pass over the
|
|
// input data. This constructor is intended for internal use by the
|
|
// distributed CSR constructors.
|
|
enum edges_are_unsorted_global_t {edges_are_unsorted_global};
|
|
|
|
/****************************************************************************
|
|
* Local helper macros to reduce typing and clutter later on. *
|
|
****************************************************************************/
|
|
#define BOOST_CSR_GRAPH_TEMPLATE_PARMS \
|
|
typename Directed, typename VertexProperty, typename EdgeProperty, \
|
|
typename GraphProperty, typename Vertex, typename EdgeIndex
|
|
#define BOOST_CSR_GRAPH_TYPE \
|
|
compressed_sparse_row_graph<Directed, VertexProperty, EdgeProperty, \
|
|
GraphProperty, Vertex, EdgeIndex>
|
|
#define BOOST_DIR_CSR_GRAPH_TEMPLATE_PARMS \
|
|
typename VertexProperty, typename EdgeProperty, \
|
|
typename GraphProperty, typename Vertex, typename EdgeIndex
|
|
#define BOOST_DIR_CSR_GRAPH_TYPE \
|
|
compressed_sparse_row_graph<directedS, VertexProperty, EdgeProperty, \
|
|
GraphProperty, Vertex, EdgeIndex>
|
|
#define BOOST_BIDIR_CSR_GRAPH_TEMPLATE_PARMS \
|
|
typename VertexProperty, typename EdgeProperty, \
|
|
typename GraphProperty, typename Vertex, typename EdgeIndex
|
|
#define BOOST_BIDIR_CSR_GRAPH_TYPE \
|
|
compressed_sparse_row_graph<bidirectionalS, VertexProperty, EdgeProperty, \
|
|
GraphProperty, Vertex, EdgeIndex>
|
|
|
|
namespace detail {
|
|
template <typename T>
|
|
struct default_construct_iterator: public boost::iterator_facade<default_construct_iterator<T>, T, boost::random_access_traversal_tag, const T&> {
|
|
typedef boost::iterator_facade<default_construct_iterator<T>, T, std::random_access_iterator_tag, const T&> base_type;
|
|
T saved_value;
|
|
const T& dereference() const {return saved_value;}
|
|
bool equal(default_construct_iterator /*i*/) const {return true;}
|
|
void increment() {}
|
|
void decrement() {}
|
|
void advance(typename base_type::difference_type) {}
|
|
typename base_type::difference_type distance_to(default_construct_iterator) const {return 0;}
|
|
};
|
|
|
|
template <typename Less>
|
|
struct compare_first {
|
|
Less less;
|
|
compare_first(Less less = Less()): less(less) {}
|
|
template <typename Tuple>
|
|
bool operator()(const Tuple& a, const Tuple& b) const {
|
|
return less(a.template get<0>(), b.template get<0>());
|
|
}
|
|
};
|
|
|
|
template <int N, typename Result>
|
|
struct my_tuple_get_class {
|
|
typedef const Result& result_type;
|
|
template <typename Tuple>
|
|
result_type operator()(const Tuple& t) const {
|
|
return t.template get<N>();
|
|
}
|
|
};
|
|
}
|
|
|
|
/** Compressed sparse row graph.
|
|
*
|
|
* Vertex and EdgeIndex should be unsigned integral types and should
|
|
* specialize numeric_limits.
|
|
*/
|
|
template<typename Directed = directedS,
|
|
typename VertexProperty = no_property,
|
|
typename EdgeProperty = no_property,
|
|
typename GraphProperty = no_property,
|
|
typename Vertex = std::size_t,
|
|
typename EdgeIndex = Vertex>
|
|
class compressed_sparse_row_graph; // Not defined
|
|
|
|
template<typename VertexProperty,
|
|
typename EdgeProperty,
|
|
typename GraphProperty,
|
|
typename Vertex,
|
|
typename EdgeIndex>
|
|
class compressed_sparse_row_graph<directedS, VertexProperty, EdgeProperty, GraphProperty, Vertex, EdgeIndex>
|
|
: public detail::indexed_vertex_properties<BOOST_DIR_CSR_GRAPH_TYPE,
|
|
VertexProperty, Vertex, typed_identity_property_map<Vertex> >
|
|
{
|
|
public:
|
|
typedef detail::indexed_vertex_properties<compressed_sparse_row_graph,
|
|
VertexProperty, Vertex, typed_identity_property_map<Vertex> >
|
|
inherited_vertex_properties;
|
|
|
|
// Some tests to prevent use of "void" is a property type (as was done in some test cases):
|
|
BOOST_STATIC_ASSERT((!is_same<VertexProperty, void>::value));
|
|
BOOST_STATIC_ASSERT((!is_same<EdgeProperty, void>::value));
|
|
BOOST_STATIC_ASSERT((!is_same<GraphProperty, void>::value));
|
|
|
|
public:
|
|
// For Property Graph
|
|
typedef GraphProperty graph_property_type;
|
|
typedef typename lookup_one_property<GraphProperty, graph_bundle_t>::type graph_bundled;
|
|
|
|
typedef detail::compressed_sparse_row_structure<EdgeProperty, Vertex, EdgeIndex> forward_type;
|
|
|
|
public:
|
|
/* At this time, the compressed sparse row graph can only be used to
|
|
* create directed and bidirectional graphs. In the future,
|
|
* undirected CSR graphs will also be supported.
|
|
*/
|
|
// BOOST_STATIC_ASSERT((is_same<Directed, directedS>::value));
|
|
|
|
// Concept requirements:
|
|
// For Graph
|
|
typedef Vertex vertex_descriptor;
|
|
typedef detail::csr_edge_descriptor<Vertex, EdgeIndex> edge_descriptor;
|
|
typedef directed_tag directed_category;
|
|
typedef allow_parallel_edge_tag edge_parallel_category;
|
|
|
|
class traversal_category: public incidence_graph_tag,
|
|
public adjacency_graph_tag,
|
|
public vertex_list_graph_tag,
|
|
public edge_list_graph_tag {};
|
|
|
|
static vertex_descriptor null_vertex() { return vertex_descriptor(-1); }
|
|
|
|
// For VertexListGraph
|
|
typedef counting_iterator<Vertex> vertex_iterator;
|
|
typedef Vertex vertices_size_type;
|
|
|
|
// For EdgeListGraph
|
|
typedef EdgeIndex edges_size_type;
|
|
|
|
// For IncidenceGraph
|
|
typedef detail::csr_out_edge_iterator<compressed_sparse_row_graph> out_edge_iterator;
|
|
typedef EdgeIndex degree_size_type;
|
|
|
|
// For AdjacencyGraph
|
|
typedef typename std::vector<Vertex>::const_iterator adjacency_iterator;
|
|
|
|
// For EdgeListGraph
|
|
typedef detail::csr_edge_iterator<compressed_sparse_row_graph> edge_iterator;
|
|
|
|
// For BidirectionalGraph (not implemented)
|
|
typedef void in_edge_iterator;
|
|
|
|
// For internal use
|
|
typedef csr_graph_tag graph_tag;
|
|
|
|
typedef typename forward_type::inherited_edge_properties::edge_bundled edge_bundled;
|
|
typedef typename forward_type::inherited_edge_properties::edge_push_back_type edge_push_back_type;
|
|
typedef typename forward_type::inherited_edge_properties::edge_property_type edge_property_type;
|
|
|
|
// Constructors
|
|
|
|
// Default constructor: an empty graph.
|
|
compressed_sparse_row_graph(): m_property() {}
|
|
|
|
// With numverts vertices
|
|
compressed_sparse_row_graph(vertices_size_type numverts)
|
|
: inherited_vertex_properties(numverts), m_forward(numverts) {}
|
|
|
|
// From number of vertices and unsorted list of edges
|
|
template <typename MultiPassInputIterator>
|
|
compressed_sparse_row_graph(edges_are_unsorted_multi_pass_t,
|
|
MultiPassInputIterator edge_begin,
|
|
MultiPassInputIterator edge_end,
|
|
vertices_size_type numverts,
|
|
const GraphProperty& prop = GraphProperty())
|
|
: inherited_vertex_properties(numverts), m_property(prop)
|
|
{
|
|
m_forward.assign_unsorted_multi_pass_edges(edge_begin, edge_end, numverts, typed_identity_property_map<vertices_size_type>(), keep_all());
|
|
}
|
|
|
|
// From number of vertices and unsorted list of edges, plus edge properties
|
|
template <typename MultiPassInputIterator, typename EdgePropertyIterator>
|
|
compressed_sparse_row_graph(edges_are_unsorted_multi_pass_t,
|
|
MultiPassInputIterator edge_begin,
|
|
MultiPassInputIterator edge_end,
|
|
EdgePropertyIterator ep_iter,
|
|
vertices_size_type numverts,
|
|
const GraphProperty& prop = GraphProperty())
|
|
: inherited_vertex_properties(numverts), m_forward(), m_property(prop)
|
|
{
|
|
m_forward.assign_unsorted_multi_pass_edges(edge_begin, edge_end, ep_iter, numverts, typed_identity_property_map<vertices_size_type>(), keep_all());
|
|
}
|
|
|
|
// From number of vertices and unsorted list of edges, with filter and
|
|
// global-to-local map
|
|
template <typename MultiPassInputIterator, typename GlobalToLocal, typename SourcePred>
|
|
compressed_sparse_row_graph(edges_are_unsorted_multi_pass_global_t,
|
|
MultiPassInputIterator edge_begin,
|
|
MultiPassInputIterator edge_end,
|
|
vertices_size_type numlocalverts,
|
|
const GlobalToLocal& global_to_local,
|
|
const SourcePred& source_pred,
|
|
const GraphProperty& prop = GraphProperty())
|
|
: inherited_vertex_properties(numlocalverts), m_forward(), m_property(prop)
|
|
{
|
|
m_forward.assign_unsorted_multi_pass_edges(edge_begin, edge_end, numlocalverts, global_to_local, source_pred);
|
|
}
|
|
|
|
// From number of vertices and unsorted list of edges, plus edge properties,
|
|
// with filter and global-to-local map
|
|
template <typename MultiPassInputIterator, typename EdgePropertyIterator, typename GlobalToLocal, typename SourcePred>
|
|
compressed_sparse_row_graph(edges_are_unsorted_multi_pass_global_t,
|
|
MultiPassInputIterator edge_begin,
|
|
MultiPassInputIterator edge_end,
|
|
EdgePropertyIterator ep_iter,
|
|
vertices_size_type numlocalverts,
|
|
const GlobalToLocal& global_to_local,
|
|
const SourcePred& source_pred,
|
|
const GraphProperty& prop = GraphProperty())
|
|
: inherited_vertex_properties(numlocalverts), m_forward(), m_property(prop)
|
|
{
|
|
m_forward.assign_unsorted_multi_pass_edges(edge_begin, edge_end, ep_iter, numlocalverts, global_to_local, source_pred);
|
|
}
|
|
|
|
// From number of vertices and sorted list of edges (new interface)
|
|
template<typename InputIterator>
|
|
compressed_sparse_row_graph(edges_are_sorted_t,
|
|
InputIterator edge_begin, InputIterator edge_end,
|
|
vertices_size_type numverts,
|
|
edges_size_type numedges = 0,
|
|
const GraphProperty& prop = GraphProperty())
|
|
: m_property(prop)
|
|
{
|
|
m_forward.assign_from_sorted_edges(edge_begin, edge_end, typed_identity_property_map<vertices_size_type>(), keep_all(), numverts, numedges);
|
|
inherited_vertex_properties::resize(numverts);
|
|
}
|
|
|
|
// From number of vertices and sorted list of edges (new interface)
|
|
template<typename InputIterator, typename EdgePropertyIterator>
|
|
compressed_sparse_row_graph(edges_are_sorted_t,
|
|
InputIterator edge_begin, InputIterator edge_end,
|
|
EdgePropertyIterator ep_iter,
|
|
vertices_size_type numverts,
|
|
edges_size_type numedges = 0,
|
|
const GraphProperty& prop = GraphProperty())
|
|
: m_property(prop)
|
|
{
|
|
m_forward.assign_from_sorted_edges(edge_begin, edge_end, ep_iter, typed_identity_property_map<vertices_size_type>(), keep_all(), numverts, numedges);
|
|
inherited_vertex_properties::resize(numverts);
|
|
}
|
|
|
|
// From number of vertices and sorted list of edges, filtered and global (new interface)
|
|
template<typename InputIterator, typename GlobalToLocal, typename SourcePred>
|
|
compressed_sparse_row_graph(edges_are_sorted_global_t,
|
|
InputIterator edge_begin, InputIterator edge_end,
|
|
const GlobalToLocal& global_to_local,
|
|
const SourcePred& source_pred,
|
|
vertices_size_type numverts,
|
|
const GraphProperty& prop = GraphProperty())
|
|
: m_property(prop)
|
|
{
|
|
m_forward.assign_from_sorted_edges(edge_begin, edge_end, global_to_local, source_pred, numverts, 0);
|
|
inherited_vertex_properties::resize(numverts);
|
|
}
|
|
|
|
// From number of vertices and sorted list of edges (new interface)
|
|
template<typename InputIterator, typename EdgePropertyIterator, typename GlobalToLocal, typename SourcePred>
|
|
compressed_sparse_row_graph(edges_are_sorted_global_t,
|
|
InputIterator edge_begin, InputIterator edge_end,
|
|
EdgePropertyIterator ep_iter,
|
|
const GlobalToLocal& global_to_local,
|
|
const SourcePred& source_pred,
|
|
vertices_size_type numverts,
|
|
const GraphProperty& prop = GraphProperty())
|
|
: m_property(prop)
|
|
{
|
|
m_forward.assign_from_sorted_edges(edge_begin, edge_end, ep_iter, global_to_local, source_pred, numverts, 0);
|
|
inherited_vertex_properties::resize(numverts);
|
|
}
|
|
|
|
// From number of vertices and mutable vectors of sources and targets;
|
|
// vectors are returned with unspecified contents but are guaranteed not to
|
|
// share storage with the constructed graph.
|
|
compressed_sparse_row_graph(construct_inplace_from_sources_and_targets_t,
|
|
std::vector<vertex_descriptor>& sources,
|
|
std::vector<vertex_descriptor>& targets,
|
|
vertices_size_type numverts,
|
|
const GraphProperty& prop = GraphProperty())
|
|
: inherited_vertex_properties(numverts), m_property(prop)
|
|
{
|
|
m_forward.assign_sources_and_targets_global(sources, targets, numverts, boost::typed_identity_property_map<vertices_size_type>());
|
|
}
|
|
|
|
// From number of vertices and mutable vectors of sources and targets,
|
|
// expressed with global vertex indices; vectors are returned with
|
|
// unspecified contents but are guaranteed not to share storage with the
|
|
// constructed graph. This constructor should only be used by the
|
|
// distributed CSR graph.
|
|
template <typename GlobalToLocal>
|
|
compressed_sparse_row_graph(construct_inplace_from_sources_and_targets_global_t,
|
|
std::vector<vertex_descriptor>& sources,
|
|
std::vector<vertex_descriptor>& targets,
|
|
vertices_size_type numlocalverts,
|
|
GlobalToLocal global_to_local,
|
|
const GraphProperty& prop = GraphProperty())
|
|
: inherited_vertex_properties(numlocalverts), m_property(prop)
|
|
{
|
|
m_forward.assign_sources_and_targets_global(sources, targets, numlocalverts, global_to_local);
|
|
}
|
|
|
|
// From number of vertices and mutable vectors of sources, targets, and edge
|
|
// properties; vectors are returned with unspecified contents but are
|
|
// guaranteed not to share storage with the constructed graph.
|
|
compressed_sparse_row_graph(construct_inplace_from_sources_and_targets_t,
|
|
std::vector<vertex_descriptor>& sources,
|
|
std::vector<vertex_descriptor>& targets,
|
|
std::vector<typename forward_type::inherited_edge_properties::edge_bundled>& edge_props,
|
|
vertices_size_type numverts,
|
|
const GraphProperty& prop = GraphProperty())
|
|
: inherited_vertex_properties(numverts), m_property(prop)
|
|
{
|
|
m_forward.assign_sources_and_targets_global(sources, targets, edge_props, numverts, boost::typed_identity_property_map<vertices_size_type>());
|
|
}
|
|
|
|
// From number of vertices and mutable vectors of sources and targets and
|
|
// edge properties, expressed with global vertex indices; vectors are
|
|
// returned with unspecified contents but are guaranteed not to share
|
|
// storage with the constructed graph. This constructor should only be used
|
|
// by the distributed CSR graph.
|
|
template <typename GlobalToLocal>
|
|
compressed_sparse_row_graph(construct_inplace_from_sources_and_targets_global_t,
|
|
std::vector<vertex_descriptor>& sources,
|
|
std::vector<vertex_descriptor>& targets,
|
|
std::vector<typename forward_type::inherited_edge_properties::edge_bundled>& edge_props,
|
|
vertices_size_type numlocalverts,
|
|
GlobalToLocal global_to_local,
|
|
const GraphProperty& prop = GraphProperty())
|
|
: inherited_vertex_properties(numlocalverts), m_property(prop)
|
|
{
|
|
m_forward.assign_sources_and_targets_global(sources, targets, edge_props, numlocalverts, global_to_local);
|
|
}
|
|
|
|
// From number of vertices and single-pass range of unsorted edges. Data is
|
|
// cached in coordinate form before creating the actual graph.
|
|
template<typename InputIterator>
|
|
compressed_sparse_row_graph(edges_are_unsorted_t,
|
|
InputIterator edge_begin, InputIterator edge_end,
|
|
vertices_size_type numverts,
|
|
const GraphProperty& prop = GraphProperty())
|
|
: inherited_vertex_properties(numverts), m_property(prop)
|
|
{
|
|
std::vector<vertex_descriptor> sources, targets;
|
|
boost::graph::detail::split_into_separate_coords
|
|
(edge_begin, edge_end, sources, targets);
|
|
m_forward.assign_sources_and_targets_global(sources, targets, numverts, boost::typed_identity_property_map<vertices_size_type>());
|
|
}
|
|
|
|
// From number of vertices and single-pass range of unsorted edges and
|
|
// single-pass range of edge properties. Data is cached in coordinate form
|
|
// before creating the actual graph.
|
|
template<typename InputIterator, typename EdgePropertyIterator>
|
|
compressed_sparse_row_graph(edges_are_unsorted_t,
|
|
InputIterator edge_begin, InputIterator edge_end,
|
|
EdgePropertyIterator ep_iter,
|
|
vertices_size_type numverts,
|
|
const GraphProperty& prop = GraphProperty())
|
|
: inherited_vertex_properties(numverts), m_property(prop)
|
|
{
|
|
std::vector<vertex_descriptor> sources, targets;
|
|
boost::graph::detail::split_into_separate_coords
|
|
(edge_begin, edge_end, sources, targets);
|
|
size_t numedges = sources.size();
|
|
std::vector<typename forward_type::inherited_edge_properties::edge_bundled> edge_props(numedges);
|
|
for (size_t i = 0; i < numedges; ++i) {
|
|
edge_props[i] = *ep_iter++;
|
|
}
|
|
m_forward.assign_sources_and_targets_global(sources, targets, edge_props, numverts, boost::typed_identity_property_map<vertices_size_type>());
|
|
}
|
|
|
|
// From number of vertices and single-pass range of unsorted edges. Data is
|
|
// cached in coordinate form before creating the actual graph. Edges are
|
|
// filtered and transformed for use in a distributed graph.
|
|
template<typename InputIterator, typename GlobalToLocal, typename SourcePred>
|
|
compressed_sparse_row_graph(edges_are_unsorted_global_t,
|
|
InputIterator edge_begin, InputIterator edge_end,
|
|
vertices_size_type numlocalverts,
|
|
GlobalToLocal global_to_local,
|
|
const SourcePred& source_pred,
|
|
const GraphProperty& prop = GraphProperty())
|
|
: inherited_vertex_properties(numlocalverts), m_property(prop)
|
|
{
|
|
std::vector<vertex_descriptor> sources, targets;
|
|
boost::graph::detail::split_into_separate_coords_filtered
|
|
(edge_begin, edge_end, sources, targets, source_pred);
|
|
m_forward.assign_sources_and_targets_global(sources, targets, numlocalverts, global_to_local);
|
|
}
|
|
|
|
// From number of vertices and single-pass range of unsorted edges and
|
|
// single-pass range of edge properties. Data is cached in coordinate form
|
|
// before creating the actual graph. Edges are filtered and transformed for
|
|
// use in a distributed graph.
|
|
template<typename InputIterator, typename EdgePropertyIterator,
|
|
typename GlobalToLocal, typename SourcePred>
|
|
compressed_sparse_row_graph(edges_are_unsorted_global_t,
|
|
InputIterator edge_begin, InputIterator edge_end,
|
|
EdgePropertyIterator ep_iter,
|
|
vertices_size_type numlocalverts,
|
|
GlobalToLocal global_to_local,
|
|
const SourcePred& source_pred,
|
|
const GraphProperty& prop = GraphProperty())
|
|
: inherited_vertex_properties(numlocalverts), m_property(prop)
|
|
{
|
|
std::vector<vertex_descriptor> sources, targets;
|
|
std::vector<edge_bundled> edge_props;
|
|
boost::graph::detail::split_into_separate_coords_filtered
|
|
(edge_begin, edge_end, ep_iter, sources, targets, edge_props, source_pred);
|
|
m_forward.assign_sources_and_targets_global(sources, targets, edge_props, numlocalverts, global_to_local);
|
|
}
|
|
|
|
|
|
// Requires IncidenceGraph and a vertex index map
|
|
template<typename Graph, typename VertexIndexMap>
|
|
compressed_sparse_row_graph(const Graph& g, const VertexIndexMap& vi,
|
|
vertices_size_type numverts,
|
|
edges_size_type numedges)
|
|
: m_property()
|
|
{
|
|
assign(g, vi, numverts, numedges);
|
|
inherited_vertex_properties::resize(numverts);
|
|
}
|
|
|
|
// Requires VertexListGraph and EdgeListGraph
|
|
template<typename Graph, typename VertexIndexMap>
|
|
compressed_sparse_row_graph(const Graph& g, const VertexIndexMap& vi)
|
|
: m_property()
|
|
{
|
|
typename graph_traits<Graph>::edges_size_type numedges = num_edges(g);
|
|
if (is_same<typename graph_traits<Graph>::directed_category, undirectedS>::value) {
|
|
numedges *= 2; // Double each edge (actual doubling done by out_edges function)
|
|
}
|
|
vertices_size_type numverts = num_vertices(g);
|
|
assign(g, vi, numverts, numedges);
|
|
inherited_vertex_properties::resize(numverts);
|
|
}
|
|
|
|
// Requires vertex index map plus requirements of previous constructor
|
|
template<typename Graph>
|
|
explicit compressed_sparse_row_graph(const Graph& g)
|
|
: m_property()
|
|
{
|
|
typename graph_traits<Graph>::edges_size_type numedges = num_edges(g);
|
|
if (is_same<typename graph_traits<Graph>::directed_category, undirectedS>::value) {
|
|
numedges *= 2; // Double each edge (actual doubling done by out_edges function)
|
|
}
|
|
assign(g, get(vertex_index, g), num_vertices(g), numedges);
|
|
}
|
|
|
|
// From any graph (slow and uses a lot of memory)
|
|
// Requires IncidenceGraph and a vertex index map
|
|
// Internal helper function
|
|
// Note that numedges must be doubled for undirected source graphs
|
|
template<typename Graph, typename VertexIndexMap>
|
|
void
|
|
assign(const Graph& g, const VertexIndexMap& vi,
|
|
vertices_size_type numverts, edges_size_type numedges)
|
|
{
|
|
m_forward.assign(g, vi, numverts, numedges);
|
|
inherited_vertex_properties::resize(numverts);
|
|
}
|
|
|
|
// Requires the above, plus VertexListGraph and EdgeListGraph
|
|
template<typename Graph, typename VertexIndexMap>
|
|
void assign(const Graph& g, const VertexIndexMap& vi)
|
|
{
|
|
typename graph_traits<Graph>::edges_size_type numedges = num_edges(g);
|
|
if (is_same<typename graph_traits<Graph>::directed_category, undirectedS>::value) {
|
|
numedges *= 2; // Double each edge (actual doubling done by out_edges function)
|
|
}
|
|
vertices_size_type numverts = num_vertices(g);
|
|
m_forward.assign(g, vi, numverts, numedges);
|
|
inherited_vertex_properties::resize(numverts);
|
|
}
|
|
|
|
// Requires the above, plus a vertex_index map.
|
|
template<typename Graph>
|
|
void assign(const Graph& g)
|
|
{
|
|
typename graph_traits<Graph>::edges_size_type numedges = num_edges(g);
|
|
if (is_same<typename graph_traits<Graph>::directed_category, undirectedS>::value) {
|
|
numedges *= 2; // Double each edge (actual doubling done by out_edges function)
|
|
}
|
|
vertices_size_type numverts = num_vertices(g);
|
|
m_forward.assign(g, get(vertex_index, g), numverts, numedges);
|
|
inherited_vertex_properties::resize(numverts);
|
|
}
|
|
|
|
// Add edges from a sorted (smallest sources first) range of pairs and edge
|
|
// properties
|
|
template <typename BidirectionalIteratorOrig, typename EPIterOrig,
|
|
typename GlobalToLocal>
|
|
void
|
|
add_edges_sorted_internal(
|
|
BidirectionalIteratorOrig first_sorted,
|
|
BidirectionalIteratorOrig last_sorted,
|
|
EPIterOrig ep_iter_sorted,
|
|
const GlobalToLocal& global_to_local) {
|
|
m_forward.add_edges_sorted_internal(first_sorted, last_sorted, ep_iter_sorted, global_to_local);
|
|
}
|
|
|
|
template <typename BidirectionalIteratorOrig, typename EPIterOrig>
|
|
void
|
|
add_edges_sorted_internal(
|
|
BidirectionalIteratorOrig first_sorted,
|
|
BidirectionalIteratorOrig last_sorted,
|
|
EPIterOrig ep_iter_sorted) {
|
|
m_forward.add_edges_sorted_internal(first_sorted, last_sorted, ep_iter_sorted, typed_identity_property_map<vertices_size_type>());
|
|
}
|
|
|
|
// Add edges from a sorted (smallest sources first) range of pairs
|
|
template <typename BidirectionalIteratorOrig>
|
|
void
|
|
add_edges_sorted_internal(
|
|
BidirectionalIteratorOrig first_sorted,
|
|
BidirectionalIteratorOrig last_sorted) {
|
|
m_forward.add_edges_sorted_internal(first_sorted, last_sorted, detail::default_construct_iterator<edge_bundled>());
|
|
}
|
|
|
|
template <typename BidirectionalIteratorOrig, typename GlobalToLocal>
|
|
void
|
|
add_edges_sorted_internal_global(
|
|
BidirectionalIteratorOrig first_sorted,
|
|
BidirectionalIteratorOrig last_sorted,
|
|
const GlobalToLocal& global_to_local) {
|
|
m_forward.add_edges_sorted_internal(first_sorted, last_sorted, detail::default_construct_iterator<edge_bundled>(), global_to_local);
|
|
}
|
|
|
|
template <typename BidirectionalIteratorOrig, typename EPIterOrig,
|
|
typename GlobalToLocal>
|
|
void
|
|
add_edges_sorted_internal_global(
|
|
BidirectionalIteratorOrig first_sorted,
|
|
BidirectionalIteratorOrig last_sorted,
|
|
EPIterOrig ep_iter_sorted,
|
|
const GlobalToLocal& global_to_local) {
|
|
m_forward.add_edges_sorted_internal(first_sorted, last_sorted, ep_iter_sorted, global_to_local);
|
|
}
|
|
|
|
// Add edges from a range of (source, target) pairs that are unsorted
|
|
template <typename InputIterator, typename GlobalToLocal>
|
|
inline void
|
|
add_edges_internal(InputIterator first, InputIterator last,
|
|
const GlobalToLocal& global_to_local) {
|
|
typedef compressed_sparse_row_graph Graph;
|
|
typedef typename boost::graph_traits<Graph>::vertex_descriptor vertex_t;
|
|
typedef std::vector<std::pair<vertex_t, vertex_t> > edge_vector_t;
|
|
edge_vector_t new_edges(first, last);
|
|
if (new_edges.empty()) return;
|
|
std::sort(new_edges.begin(), new_edges.end());
|
|
this->add_edges_sorted_internal_global(new_edges.begin(), new_edges.end(), global_to_local);
|
|
}
|
|
|
|
template <typename InputIterator>
|
|
inline void
|
|
add_edges_internal(InputIterator first, InputIterator last) {
|
|
this->add_edges_internal(first, last, typed_identity_property_map<vertices_size_type>());
|
|
}
|
|
|
|
// Add edges from a range of (source, target) pairs and edge properties that
|
|
// are unsorted
|
|
template <typename InputIterator, typename EPIterator, typename GlobalToLocal>
|
|
inline void
|
|
add_edges_internal(InputIterator first, InputIterator last,
|
|
EPIterator ep_iter, EPIterator ep_iter_end,
|
|
const GlobalToLocal& global_to_local) {
|
|
typedef compressed_sparse_row_graph Graph;
|
|
typedef typename boost::graph_traits<Graph>::vertex_descriptor vertex_t;
|
|
typedef std::pair<vertex_t, vertex_t> vertex_pair;
|
|
typedef std::vector<
|
|
boost::tuple<vertex_pair,
|
|
edge_bundled> >
|
|
edge_vector_t;
|
|
edge_vector_t new_edges
|
|
(boost::make_zip_iterator(boost::make_tuple(first, ep_iter)),
|
|
boost::make_zip_iterator(boost::make_tuple(last, ep_iter_end)));
|
|
if (new_edges.empty()) return;
|
|
std::sort(new_edges.begin(), new_edges.end(),
|
|
boost::detail::compare_first<
|
|
std::less<vertex_pair> >());
|
|
m_forward.add_edges_sorted_internal
|
|
(boost::make_transform_iterator(
|
|
new_edges.begin(),
|
|
boost::detail::my_tuple_get_class<0, vertex_pair>()),
|
|
boost::make_transform_iterator(
|
|
new_edges.end(),
|
|
boost::detail::my_tuple_get_class<0, vertex_pair>()),
|
|
boost::make_transform_iterator(
|
|
new_edges.begin(),
|
|
boost::detail::my_tuple_get_class
|
|
<1, edge_bundled>()),
|
|
global_to_local);
|
|
}
|
|
|
|
// Add edges from a range of (source, target) pairs and edge properties that
|
|
// are unsorted
|
|
template <typename InputIterator, typename EPIterator>
|
|
inline void
|
|
add_edges_internal(InputIterator first, InputIterator last,
|
|
EPIterator ep_iter, EPIterator ep_iter_end) {
|
|
this->add_edges_internal(first, last, ep_iter, ep_iter_end, typed_identity_property_map<vertices_size_type>());
|
|
}
|
|
|
|
using inherited_vertex_properties::operator[];
|
|
|
|
// Directly access a edge or edge bundle
|
|
edge_push_back_type& operator[](const edge_descriptor& v)
|
|
{ return m_forward.m_edge_properties[get(edge_index, *this, v)]; }
|
|
|
|
const edge_push_back_type& operator[](const edge_descriptor& v) const
|
|
{ return m_forward.m_edge_properties[get(edge_index, *this, v)]; }
|
|
|
|
// Directly access a graph bundle
|
|
graph_bundled& operator[](graph_bundle_t)
|
|
{ return get_property(*this); }
|
|
|
|
const graph_bundled& operator[](graph_bundle_t) const
|
|
{ return get_property(*this); }
|
|
|
|
// private: non-portable, requires friend templates
|
|
inherited_vertex_properties& vertex_properties() {return *this;}
|
|
const inherited_vertex_properties& vertex_properties() const {return *this;}
|
|
typename forward_type::inherited_edge_properties& edge_properties() { return m_forward; }
|
|
const typename forward_type::inherited_edge_properties& edge_properties() const { return m_forward; }
|
|
|
|
forward_type m_forward;
|
|
GraphProperty m_property;
|
|
};
|
|
|
|
template<typename VertexProperty,
|
|
typename EdgeProperty,
|
|
typename GraphProperty,
|
|
typename Vertex,
|
|
typename EdgeIndex>
|
|
class compressed_sparse_row_graph<bidirectionalS, VertexProperty, EdgeProperty, GraphProperty, Vertex, EdgeIndex>
|
|
: public detail::indexed_vertex_properties<BOOST_BIDIR_CSR_GRAPH_TYPE,
|
|
VertexProperty, Vertex, typed_identity_property_map<Vertex> >
|
|
{
|
|
public:
|
|
typedef detail::indexed_vertex_properties<compressed_sparse_row_graph,
|
|
VertexProperty, Vertex, typed_identity_property_map<Vertex> >
|
|
inherited_vertex_properties;
|
|
|
|
public:
|
|
// For Property Graph
|
|
typedef GraphProperty graph_property_type;
|
|
typedef typename lookup_one_property<GraphProperty, graph_bundle_t>::type graph_bundled;
|
|
// typedef GraphProperty graph_property_type;
|
|
|
|
typedef detail::compressed_sparse_row_structure<EdgeProperty, Vertex, EdgeIndex> forward_type;
|
|
typedef EdgeIndex /* typename boost::mpl::if_c<boost::is_same<EdgeProperty, boost::no_property>, boost::no_property, EdgeIndex> */ backward_edge_property;
|
|
typedef detail::compressed_sparse_row_structure<backward_edge_property, Vertex, EdgeIndex> backward_type;
|
|
|
|
public:
|
|
// Concept requirements:
|
|
// For Graph
|
|
typedef Vertex vertex_descriptor;
|
|
typedef detail::csr_edge_descriptor<Vertex, EdgeIndex> edge_descriptor;
|
|
typedef bidirectional_tag directed_category;
|
|
typedef allow_parallel_edge_tag edge_parallel_category;
|
|
|
|
class traversal_category: public bidirectional_graph_tag,
|
|
public adjacency_graph_tag,
|
|
public vertex_list_graph_tag,
|
|
public edge_list_graph_tag {};
|
|
|
|
static vertex_descriptor null_vertex() { return vertex_descriptor(-1); }
|
|
|
|
// For VertexListGraph
|
|
typedef counting_iterator<Vertex> vertex_iterator;
|
|
typedef Vertex vertices_size_type;
|
|
|
|
// For EdgeListGraph
|
|
typedef EdgeIndex edges_size_type;
|
|
|
|
// For IncidenceGraph
|
|
typedef detail::csr_out_edge_iterator<compressed_sparse_row_graph> out_edge_iterator;
|
|
typedef EdgeIndex degree_size_type;
|
|
|
|
// For AdjacencyGraph
|
|
typedef typename std::vector<Vertex>::const_iterator adjacency_iterator;
|
|
|
|
// For EdgeListGraph
|
|
typedef detail::csr_edge_iterator<compressed_sparse_row_graph> edge_iterator;
|
|
|
|
// For BidirectionalGraph (not implemented)
|
|
typedef detail::csr_in_edge_iterator<compressed_sparse_row_graph> in_edge_iterator;
|
|
|
|
// For internal use
|
|
typedef csr_graph_tag graph_tag;
|
|
|
|
typedef typename forward_type::inherited_edge_properties::edge_bundled edge_bundled;
|
|
typedef typename forward_type::inherited_edge_properties::edge_push_back_type edge_push_back_type;
|
|
typedef typename forward_type::inherited_edge_properties::edge_property_type edge_property_type;
|
|
|
|
// Constructors
|
|
|
|
// Default constructor: an empty graph.
|
|
compressed_sparse_row_graph(): m_property() {}
|
|
|
|
// With numverts vertices
|
|
compressed_sparse_row_graph(vertices_size_type numverts)
|
|
: inherited_vertex_properties(numverts),
|
|
m_forward(numverts), m_backward(numverts) {}
|
|
|
|
private:
|
|
|
|
void set_up_backward_property_links() {
|
|
std::pair<edge_iterator, edge_iterator> e = edges(*this);
|
|
m_backward.assign_unsorted_multi_pass_edges
|
|
(detail::transpose_edges(
|
|
detail::make_edge_to_index_pair_iter
|
|
(*this, get(vertex_index, *this), e.first)),
|
|
detail::transpose_edges(
|
|
detail::make_edge_to_index_pair_iter
|
|
(*this, get(vertex_index, *this), e.second)),
|
|
boost::counting_iterator<EdgeIndex>(0),
|
|
m_forward.m_rowstart.size() - 1,
|
|
typed_identity_property_map<Vertex>(),
|
|
keep_all());
|
|
}
|
|
|
|
public:
|
|
|
|
// From number of vertices and unsorted list of edges
|
|
template <typename MultiPassInputIterator>
|
|
compressed_sparse_row_graph(edges_are_unsorted_multi_pass_t,
|
|
MultiPassInputIterator edge_begin,
|
|
MultiPassInputIterator edge_end,
|
|
vertices_size_type numverts,
|
|
const GraphProperty& prop = GraphProperty())
|
|
: inherited_vertex_properties(numverts), m_property(prop)
|
|
{
|
|
m_forward.assign_unsorted_multi_pass_edges(edge_begin, edge_end, numverts, typed_identity_property_map<Vertex>(), keep_all());
|
|
set_up_backward_property_links();
|
|
}
|
|
|
|
// From number of vertices and unsorted list of edges, plus edge properties
|
|
template <typename MultiPassInputIterator, typename EdgePropertyIterator>
|
|
compressed_sparse_row_graph(edges_are_unsorted_multi_pass_t,
|
|
MultiPassInputIterator edge_begin,
|
|
MultiPassInputIterator edge_end,
|
|
EdgePropertyIterator ep_iter,
|
|
vertices_size_type numverts,
|
|
const GraphProperty& prop = GraphProperty())
|
|
: inherited_vertex_properties(numverts), m_forward(), m_property(prop)
|
|
{
|
|
m_forward.assign_unsorted_multi_pass_edges(edge_begin, edge_end, ep_iter, numverts, typed_identity_property_map<Vertex>(), keep_all());
|
|
set_up_backward_property_links();
|
|
}
|
|
|
|
// From number of vertices and unsorted list of edges, with filter and
|
|
// global-to-local map
|
|
template <typename MultiPassInputIterator, typename GlobalToLocal, typename SourcePred>
|
|
compressed_sparse_row_graph(edges_are_unsorted_multi_pass_global_t,
|
|
MultiPassInputIterator edge_begin,
|
|
MultiPassInputIterator edge_end,
|
|
vertices_size_type numlocalverts,
|
|
const GlobalToLocal& global_to_local,
|
|
const SourcePred& source_pred,
|
|
const GraphProperty& prop = GraphProperty())
|
|
: inherited_vertex_properties(numlocalverts), m_forward(), m_property(prop)
|
|
{
|
|
m_forward.assign_unsorted_multi_pass_edges(edge_begin, edge_end, numlocalverts, global_to_local, source_pred);
|
|
set_up_backward_property_links();
|
|
}
|
|
|
|
// From number of vertices and unsorted list of edges, plus edge properties,
|
|
// with filter and global-to-local map
|
|
template <typename MultiPassInputIterator, typename EdgePropertyIterator, typename GlobalToLocal, typename SourcePred>
|
|
compressed_sparse_row_graph(edges_are_unsorted_multi_pass_global_t,
|
|
MultiPassInputIterator edge_begin,
|
|
MultiPassInputIterator edge_end,
|
|
EdgePropertyIterator ep_iter,
|
|
vertices_size_type numlocalverts,
|
|
const GlobalToLocal& global_to_local,
|
|
const SourcePred& source_pred,
|
|
const GraphProperty& prop = GraphProperty())
|
|
: inherited_vertex_properties(numlocalverts), m_forward(), m_property(prop)
|
|
{
|
|
m_forward.assign_unsorted_multi_pass_edges(edge_begin, edge_end, ep_iter, numlocalverts, global_to_local, source_pred);
|
|
set_up_backward_property_links();
|
|
}
|
|
|
|
// Requires IncidenceGraph and a vertex index map
|
|
template<typename Graph, typename VertexIndexMap>
|
|
compressed_sparse_row_graph(const Graph& g, const VertexIndexMap& vi,
|
|
vertices_size_type numverts,
|
|
edges_size_type numedges)
|
|
: m_property()
|
|
{
|
|
assign(g, vi, numverts, numedges);
|
|
inherited_vertex_properties::resize(numverts);
|
|
}
|
|
|
|
// Requires VertexListGraph and EdgeListGraph
|
|
template<typename Graph, typename VertexIndexMap>
|
|
compressed_sparse_row_graph(const Graph& g, const VertexIndexMap& vi)
|
|
: m_property()
|
|
{
|
|
typename graph_traits<Graph>::edges_size_type numedges = num_edges(g);
|
|
if (is_same<typename graph_traits<Graph>::directed_category, undirectedS>::value) {
|
|
numedges *= 2; // Double each edge (actual doubling done by out_edges function)
|
|
}
|
|
vertices_size_type numverts = num_vertices(g);
|
|
assign(g, vi, numverts, numedges);
|
|
inherited_vertex_properties::resize(numverts);
|
|
}
|
|
|
|
// Requires vertex index map plus requirements of previous constructor
|
|
template<typename Graph>
|
|
explicit compressed_sparse_row_graph(const Graph& g)
|
|
: m_property()
|
|
{
|
|
typename graph_traits<Graph>::edges_size_type numedges = num_edges(g);
|
|
if (is_same<typename graph_traits<Graph>::directed_category, undirectedS>::value) {
|
|
numedges *= 2; // Double each edge (actual doubling done by out_edges function)
|
|
}
|
|
assign(g, get(vertex_index, g), num_vertices(g), numedges);
|
|
}
|
|
|
|
// From any graph (slow and uses a lot of memory)
|
|
// Requires IncidenceGraph and a vertex index map
|
|
// Internal helper function
|
|
// Note that numedges must be doubled for undirected source graphs
|
|
template<typename Graph, typename VertexIndexMap>
|
|
void
|
|
assign(const Graph& g, const VertexIndexMap& vi,
|
|
vertices_size_type numverts, edges_size_type numedges)
|
|
{
|
|
m_forward.assign(g, vi, numverts, numedges);
|
|
inherited_vertex_properties::resize(numverts);
|
|
set_up_backward_property_links();
|
|
}
|
|
|
|
// Requires the above, plus VertexListGraph and EdgeListGraph
|
|
template<typename Graph, typename VertexIndexMap>
|
|
void assign(const Graph& g, const VertexIndexMap& vi)
|
|
{
|
|
typename graph_traits<Graph>::edges_size_type numedges = num_edges(g);
|
|
if (is_same<typename graph_traits<Graph>::directed_category, undirectedS>::value) {
|
|
numedges *= 2; // Double each edge (actual doubling done by out_edges function)
|
|
}
|
|
vertices_size_type numverts = num_vertices(g);
|
|
m_forward.assign(g, vi, numverts, numedges);
|
|
inherited_vertex_properties::resize(numverts);
|
|
set_up_backward_property_links();
|
|
}
|
|
|
|
// Requires the above, plus a vertex_index map.
|
|
template<typename Graph>
|
|
void assign(const Graph& g)
|
|
{
|
|
typename graph_traits<Graph>::edges_size_type numedges = num_edges(g);
|
|
if (is_same<typename graph_traits<Graph>::directed_category, undirectedS>::value) {
|
|
numedges *= 2; // Double each edge (actual doubling done by out_edges function)
|
|
}
|
|
vertices_size_type numverts = num_vertices(g);
|
|
m_forward.assign(g, get(vertex_index, g), numverts, numedges);
|
|
inherited_vertex_properties::resize(numverts);
|
|
set_up_backward_property_links();
|
|
}
|
|
|
|
using inherited_vertex_properties::operator[];
|
|
|
|
// Directly access a edge or edge bundle
|
|
edge_push_back_type& operator[](const edge_descriptor& v)
|
|
{ return m_forward.m_edge_properties[get(edge_index, *this, v)]; }
|
|
|
|
const edge_push_back_type& operator[](const edge_descriptor& v) const
|
|
{ return m_forward.m_edge_properties[get(edge_index, *this, v)]; }
|
|
|
|
// private: non-portable, requires friend templates
|
|
inherited_vertex_properties& vertex_properties() {return *this;}
|
|
const inherited_vertex_properties& vertex_properties() const {return *this;}
|
|
typename forward_type::inherited_edge_properties& edge_properties() { return m_forward; }
|
|
const typename forward_type::inherited_edge_properties& edge_properties() const { return m_forward; }
|
|
|
|
forward_type m_forward;
|
|
backward_type m_backward;
|
|
GraphProperty m_property;
|
|
};
|
|
|
|
// Construction functions
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
|
|
inline Vertex
|
|
add_vertex(BOOST_CSR_GRAPH_TYPE& g) {
|
|
add_vertex(g, typename BOOST_CSR_GRAPH_TYPE::vertex_bundled());
|
|
}
|
|
|
|
template<BOOST_DIR_CSR_GRAPH_TEMPLATE_PARMS>
|
|
inline Vertex
|
|
add_vertex(BOOST_DIR_CSR_GRAPH_TYPE& g,
|
|
typename BOOST_DIR_CSR_GRAPH_TYPE::vertex_bundled const& p) {
|
|
Vertex old_num_verts_plus_one = g.m_forward.m_rowstart.size();
|
|
g.m_forward.m_rowstart.push_back(g.m_forward.m_rowstart.back());
|
|
g.vertex_properties().push_back(p);
|
|
return old_num_verts_plus_one - 1;
|
|
}
|
|
|
|
template<BOOST_BIDIR_CSR_GRAPH_TEMPLATE_PARMS>
|
|
inline Vertex
|
|
add_vertex(BOOST_BIDIR_CSR_GRAPH_TYPE& g,
|
|
typename BOOST_BIDIR_CSR_GRAPH_TYPE::vertex_bundled const& p) {
|
|
Vertex old_num_verts_plus_one = g.m_forward.m_rowstart.size();
|
|
g.m_forward.m_rowstart.push_back(g.m_forward.m_rowstart.back());
|
|
g.m_backward.m_rowstart.push_back(g.m_backward.m_rowstart.back());
|
|
g.vertex_properties().push_back(p);
|
|
return old_num_verts_plus_one - 1;
|
|
}
|
|
|
|
template<BOOST_DIR_CSR_GRAPH_TEMPLATE_PARMS>
|
|
inline Vertex
|
|
add_vertices(typename BOOST_DIR_CSR_GRAPH_TYPE::vertices_size_type count, BOOST_DIR_CSR_GRAPH_TYPE& g) {
|
|
Vertex old_num_verts_plus_one = g.m_forward.m_rowstart.size();
|
|
EdgeIndex numedges = g.m_forward.m_rowstart.back();
|
|
g.m_forward.m_rowstart.resize(old_num_verts_plus_one + count, numedges);
|
|
g.vertex_properties().resize(num_vertices(g));
|
|
return old_num_verts_plus_one - 1;
|
|
}
|
|
|
|
// Add edges from a sorted (smallest sources first) range of pairs and edge
|
|
// properties
|
|
template <BOOST_DIR_CSR_GRAPH_TEMPLATE_PARMS, typename BidirectionalIteratorOrig,
|
|
typename EPIterOrig>
|
|
void
|
|
add_edges_sorted(
|
|
BidirectionalIteratorOrig first_sorted,
|
|
BidirectionalIteratorOrig last_sorted,
|
|
EPIterOrig ep_iter_sorted,
|
|
BOOST_DIR_CSR_GRAPH_TYPE& g) {
|
|
g.add_edges_sorted_internal(first_sorted, last_sorted, ep_iter_sorted);
|
|
}
|
|
|
|
// Add edges from a sorted (smallest sources first) range of pairs
|
|
template <BOOST_DIR_CSR_GRAPH_TEMPLATE_PARMS, typename BidirectionalIteratorOrig>
|
|
void
|
|
add_edges_sorted(
|
|
BidirectionalIteratorOrig first_sorted,
|
|
BidirectionalIteratorOrig last_sorted,
|
|
BOOST_DIR_CSR_GRAPH_TYPE& g) {
|
|
g.add_edges_sorted_internal(first_sorted, last_sorted);
|
|
}
|
|
|
|
template <BOOST_DIR_CSR_GRAPH_TEMPLATE_PARMS, typename BidirectionalIteratorOrig,
|
|
typename EPIterOrig, typename GlobalToLocal>
|
|
void
|
|
add_edges_sorted_global(
|
|
BidirectionalIteratorOrig first_sorted,
|
|
BidirectionalIteratorOrig last_sorted,
|
|
EPIterOrig ep_iter_sorted,
|
|
const GlobalToLocal& global_to_local,
|
|
BOOST_DIR_CSR_GRAPH_TYPE& g) {
|
|
g.add_edges_sorted_internal_global(first_sorted, last_sorted, ep_iter_sorted,
|
|
global_to_local);
|
|
}
|
|
|
|
// Add edges from a sorted (smallest sources first) range of pairs
|
|
template <BOOST_DIR_CSR_GRAPH_TEMPLATE_PARMS, typename BidirectionalIteratorOrig,
|
|
typename GlobalToLocal>
|
|
void
|
|
add_edges_sorted_global(
|
|
BidirectionalIteratorOrig first_sorted,
|
|
BidirectionalIteratorOrig last_sorted,
|
|
const GlobalToLocal& global_to_local,
|
|
BOOST_DIR_CSR_GRAPH_TYPE& g) {
|
|
g.add_edges_sorted_internal_global(first_sorted, last_sorted, global_to_local);
|
|
}
|
|
|
|
// Add edges from a range of (source, target) pairs that are unsorted
|
|
template <BOOST_DIR_CSR_GRAPH_TEMPLATE_PARMS, typename InputIterator,
|
|
typename GlobalToLocal>
|
|
inline void
|
|
add_edges_global(InputIterator first, InputIterator last,
|
|
const GlobalToLocal& global_to_local, BOOST_DIR_CSR_GRAPH_TYPE& g) {
|
|
g.add_edges_internal(first, last, global_to_local);
|
|
}
|
|
|
|
// Add edges from a range of (source, target) pairs that are unsorted
|
|
template <BOOST_DIR_CSR_GRAPH_TEMPLATE_PARMS, typename InputIterator>
|
|
inline void
|
|
add_edges(InputIterator first, InputIterator last, BOOST_DIR_CSR_GRAPH_TYPE& g) {
|
|
g.add_edges_internal(first, last);
|
|
}
|
|
|
|
// Add edges from a range of (source, target) pairs and edge properties that
|
|
// are unsorted
|
|
template <BOOST_DIR_CSR_GRAPH_TEMPLATE_PARMS,
|
|
typename InputIterator, typename EPIterator>
|
|
inline void
|
|
add_edges(InputIterator first, InputIterator last,
|
|
EPIterator ep_iter, EPIterator ep_iter_end,
|
|
BOOST_DIR_CSR_GRAPH_TYPE& g) {
|
|
g.add_edges_internal(first, last, ep_iter, ep_iter_end);
|
|
}
|
|
|
|
template <BOOST_DIR_CSR_GRAPH_TEMPLATE_PARMS,
|
|
typename InputIterator, typename EPIterator, typename GlobalToLocal>
|
|
inline void
|
|
add_edges_global(InputIterator first, InputIterator last,
|
|
EPIterator ep_iter, EPIterator ep_iter_end,
|
|
const GlobalToLocal& global_to_local,
|
|
BOOST_DIR_CSR_GRAPH_TYPE& g) {
|
|
g.add_edges_internal(first, last, ep_iter, ep_iter_end, global_to_local);
|
|
}
|
|
|
|
// From VertexListGraph
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
|
|
inline Vertex
|
|
num_vertices(const BOOST_CSR_GRAPH_TYPE& g) {
|
|
return g.m_forward.m_rowstart.size() - 1;
|
|
}
|
|
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
|
|
std::pair<counting_iterator<Vertex>, counting_iterator<Vertex> >
|
|
inline vertices(const BOOST_CSR_GRAPH_TYPE& g) {
|
|
return std::make_pair(counting_iterator<Vertex>(0),
|
|
counting_iterator<Vertex>(num_vertices(g)));
|
|
}
|
|
|
|
// From IncidenceGraph
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
|
|
inline Vertex
|
|
source(typename BOOST_CSR_GRAPH_TYPE::edge_descriptor e,
|
|
const BOOST_CSR_GRAPH_TYPE&)
|
|
{
|
|
return e.src;
|
|
}
|
|
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
|
|
inline Vertex
|
|
target(typename BOOST_CSR_GRAPH_TYPE::edge_descriptor e,
|
|
const BOOST_CSR_GRAPH_TYPE& g)
|
|
{
|
|
return g.m_forward.m_column[e.idx];
|
|
}
|
|
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
|
|
inline std::pair<typename BOOST_CSR_GRAPH_TYPE::out_edge_iterator,
|
|
typename BOOST_CSR_GRAPH_TYPE::out_edge_iterator>
|
|
out_edges(Vertex v, const BOOST_CSR_GRAPH_TYPE& g)
|
|
{
|
|
typedef typename BOOST_CSR_GRAPH_TYPE::edge_descriptor ed;
|
|
typedef typename BOOST_CSR_GRAPH_TYPE::out_edge_iterator it;
|
|
EdgeIndex v_row_start = g.m_forward.m_rowstart[v];
|
|
EdgeIndex next_row_start = g.m_forward.m_rowstart[v + 1];
|
|
return std::make_pair(it(ed(v, v_row_start)),
|
|
it(ed(v, next_row_start)));
|
|
}
|
|
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
|
|
inline EdgeIndex
|
|
out_degree(Vertex v, const BOOST_CSR_GRAPH_TYPE& g)
|
|
{
|
|
EdgeIndex v_row_start = g.m_forward.m_rowstart[v];
|
|
EdgeIndex next_row_start = g.m_forward.m_rowstart[v + 1];
|
|
return next_row_start - v_row_start;
|
|
}
|
|
|
|
template<BOOST_BIDIR_CSR_GRAPH_TEMPLATE_PARMS>
|
|
inline std::pair<typename BOOST_BIDIR_CSR_GRAPH_TYPE::in_edge_iterator,
|
|
typename BOOST_BIDIR_CSR_GRAPH_TYPE::in_edge_iterator>
|
|
in_edges(Vertex v, const BOOST_BIDIR_CSR_GRAPH_TYPE& g)
|
|
{
|
|
typedef typename BOOST_BIDIR_CSR_GRAPH_TYPE::in_edge_iterator it;
|
|
EdgeIndex v_row_start = g.m_backward.m_rowstart[v];
|
|
EdgeIndex next_row_start = g.m_backward.m_rowstart[v + 1];
|
|
return std::make_pair(it(g, v_row_start),
|
|
it(g, next_row_start));
|
|
}
|
|
|
|
template<BOOST_BIDIR_CSR_GRAPH_TEMPLATE_PARMS>
|
|
inline EdgeIndex
|
|
in_degree(Vertex v, const BOOST_BIDIR_CSR_GRAPH_TYPE& g)
|
|
{
|
|
EdgeIndex v_row_start = g.m_backward.m_rowstart[v];
|
|
EdgeIndex next_row_start = g.m_backward.m_rowstart[v + 1];
|
|
return next_row_start - v_row_start;
|
|
}
|
|
|
|
// From AdjacencyGraph
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
|
|
inline std::pair<typename BOOST_CSR_GRAPH_TYPE::adjacency_iterator,
|
|
typename BOOST_CSR_GRAPH_TYPE::adjacency_iterator>
|
|
adjacent_vertices(Vertex v, const BOOST_CSR_GRAPH_TYPE& g)
|
|
{
|
|
EdgeIndex v_row_start = g.m_forward.m_rowstart[v];
|
|
EdgeIndex next_row_start = g.m_forward.m_rowstart[v + 1];
|
|
return std::make_pair(g.m_forward.m_column.begin() + v_row_start,
|
|
g.m_forward.m_column.begin() + next_row_start);
|
|
}
|
|
|
|
// Extra, common functions
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
|
|
inline typename graph_traits<BOOST_CSR_GRAPH_TYPE>::vertex_descriptor
|
|
vertex(typename graph_traits<BOOST_CSR_GRAPH_TYPE>::vertex_descriptor i,
|
|
const BOOST_CSR_GRAPH_TYPE&)
|
|
{
|
|
return i;
|
|
}
|
|
|
|
// edge() can be provided in linear time for the new interface
|
|
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
|
|
inline std::pair<typename BOOST_CSR_GRAPH_TYPE::edge_descriptor, bool>
|
|
edge(Vertex i, Vertex j, const BOOST_CSR_GRAPH_TYPE& g)
|
|
{
|
|
typedef typename BOOST_CSR_GRAPH_TYPE::out_edge_iterator out_edge_iter;
|
|
std::pair<out_edge_iter, out_edge_iter> range = out_edges(i, g);
|
|
for (; range.first != range.second; ++range.first) {
|
|
if (target(*range.first, g) == j)
|
|
return std::make_pair(*range.first, true);
|
|
}
|
|
return std::make_pair(typename BOOST_CSR_GRAPH_TYPE::edge_descriptor(),
|
|
false);
|
|
}
|
|
|
|
// Find an edge given its index in the graph
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
|
|
inline typename BOOST_CSR_GRAPH_TYPE::edge_descriptor
|
|
edge_from_index(EdgeIndex idx, const BOOST_CSR_GRAPH_TYPE& g)
|
|
{
|
|
typedef typename std::vector<EdgeIndex>::const_iterator row_start_iter;
|
|
BOOST_ASSERT (idx < num_edges(g));
|
|
row_start_iter src_plus_1 =
|
|
std::upper_bound(g.m_forward.m_rowstart.begin(),
|
|
g.m_forward.m_rowstart.end(),
|
|
idx);
|
|
// Get last source whose rowstart is at most idx
|
|
// upper_bound returns this position plus 1
|
|
Vertex src = (src_plus_1 - g.m_forward.m_rowstart.begin()) - 1;
|
|
return typename BOOST_CSR_GRAPH_TYPE::edge_descriptor(src, idx);
|
|
}
|
|
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
|
|
inline EdgeIndex
|
|
num_edges(const BOOST_CSR_GRAPH_TYPE& g)
|
|
{
|
|
return g.m_forward.m_column.size();
|
|
}
|
|
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
|
|
std::pair<typename BOOST_CSR_GRAPH_TYPE::edge_iterator,
|
|
typename BOOST_CSR_GRAPH_TYPE::edge_iterator>
|
|
edges(const BOOST_CSR_GRAPH_TYPE& g)
|
|
{
|
|
typedef typename BOOST_CSR_GRAPH_TYPE::edge_iterator ei;
|
|
typedef typename BOOST_CSR_GRAPH_TYPE::edge_descriptor edgedesc;
|
|
if (g.m_forward.m_rowstart.size() == 1 || g.m_forward.m_column.empty()) {
|
|
return std::make_pair(ei(), ei());
|
|
} else {
|
|
// Find the first vertex that has outgoing edges
|
|
Vertex src = 0;
|
|
while (g.m_forward.m_rowstart[src + 1] == 0) ++src;
|
|
return std::make_pair(ei(g, edgedesc(src, 0), g.m_forward.m_rowstart[src + 1]),
|
|
ei(g, edgedesc(num_vertices(g), g.m_forward.m_column.size()), 0));
|
|
}
|
|
}
|
|
|
|
// For Property Graph
|
|
|
|
// Graph properties
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS, class Tag, class Value>
|
|
inline void
|
|
set_property(BOOST_CSR_GRAPH_TYPE& g, Tag tag, const Value& value)
|
|
{
|
|
get_property_value(g.m_property, tag) = value;
|
|
}
|
|
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS, class Tag>
|
|
inline
|
|
typename graph_property<BOOST_CSR_GRAPH_TYPE, Tag>::type&
|
|
get_property(BOOST_CSR_GRAPH_TYPE& g, Tag tag)
|
|
{
|
|
return get_property_value(g.m_property, tag);
|
|
}
|
|
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS, class Tag>
|
|
inline
|
|
const
|
|
typename graph_property<BOOST_CSR_GRAPH_TYPE, Tag>::type&
|
|
get_property(const BOOST_CSR_GRAPH_TYPE& g, Tag tag)
|
|
{
|
|
return get_property_value(g.m_property, tag);
|
|
}
|
|
|
|
template <typename G, typename Tag, typename Kind>
|
|
struct csr_property_map_helper {};
|
|
// Kind == void for invalid property tags, so we can use that to SFINAE out
|
|
|
|
template <BOOST_CSR_GRAPH_TEMPLATE_PARMS, typename Tag>
|
|
struct csr_property_map_helper<BOOST_CSR_GRAPH_TYPE, Tag, vertex_property_tag> {
|
|
typedef vertex_all_t all_tag;
|
|
typedef typename property_traits<typename property_map<BOOST_CSR_GRAPH_TYPE, vertex_all_t>::type>::key_type key_type;
|
|
typedef VertexProperty plist_type;
|
|
typedef typename property_map<BOOST_CSR_GRAPH_TYPE, vertex_all_t>::type all_type;
|
|
typedef typename property_map<BOOST_CSR_GRAPH_TYPE, vertex_all_t>::const_type all_const_type;
|
|
typedef transform_value_property_map<detail::lookup_one_property_f<plist_type, Tag>, all_type> type;
|
|
typedef transform_value_property_map<detail::lookup_one_property_f<const plist_type, Tag>, all_const_type> const_type;
|
|
};
|
|
|
|
template <BOOST_CSR_GRAPH_TEMPLATE_PARMS, typename Tag>
|
|
struct csr_property_map_helper<BOOST_CSR_GRAPH_TYPE, Tag, edge_property_tag> {
|
|
typedef edge_all_t all_tag;
|
|
typedef typename property_traits<typename property_map<BOOST_CSR_GRAPH_TYPE, edge_all_t>::type>::key_type key_type;
|
|
typedef EdgeProperty plist_type;
|
|
typedef typename property_map<BOOST_CSR_GRAPH_TYPE, edge_all_t>::type all_type;
|
|
typedef typename property_map<BOOST_CSR_GRAPH_TYPE, edge_all_t>::const_type all_const_type;
|
|
typedef transform_value_property_map<detail::lookup_one_property_f<plist_type, Tag>, all_type> type;
|
|
typedef transform_value_property_map<detail::lookup_one_property_f<const plist_type, Tag>, all_const_type> const_type;
|
|
};
|
|
|
|
template <BOOST_CSR_GRAPH_TEMPLATE_PARMS, typename Tag>
|
|
struct csr_property_map_helper<BOOST_CSR_GRAPH_TYPE, Tag, graph_property_tag> {
|
|
typedef graph_all_t all_tag;
|
|
typedef BOOST_CSR_GRAPH_TYPE* key_type;
|
|
typedef GraphProperty plist_type;
|
|
typedef typename property_map<BOOST_CSR_GRAPH_TYPE, graph_all_t>::type all_type;
|
|
typedef typename property_map<BOOST_CSR_GRAPH_TYPE, graph_all_t>::const_type all_const_type;
|
|
typedef transform_value_property_map<detail::lookup_one_property_f<plist_type, Tag>, all_type> type;
|
|
typedef transform_value_property_map<detail::lookup_one_property_f<const plist_type, Tag>, all_const_type> const_type;
|
|
};
|
|
|
|
// disable_if isn't truly necessary but required to avoid ambiguity with specializations below
|
|
template <BOOST_CSR_GRAPH_TEMPLATE_PARMS, typename Tag>
|
|
struct property_map<BOOST_CSR_GRAPH_TYPE, Tag, typename disable_if<detail::is_distributed_selector<Vertex> >::type>:
|
|
csr_property_map_helper<
|
|
BOOST_CSR_GRAPH_TYPE,
|
|
Tag,
|
|
typename detail::property_kind_from_graph<BOOST_CSR_GRAPH_TYPE, Tag>
|
|
::type> {};
|
|
|
|
template <BOOST_CSR_GRAPH_TEMPLATE_PARMS, typename Tag>
|
|
typename property_map<BOOST_CSR_GRAPH_TYPE, Tag>::type
|
|
get(Tag tag, BOOST_CSR_GRAPH_TYPE& g) {
|
|
return typename property_map<BOOST_CSR_GRAPH_TYPE, Tag>::type(tag, get(typename property_map<BOOST_CSR_GRAPH_TYPE, Tag>::all_tag(), g));
|
|
}
|
|
|
|
template <BOOST_CSR_GRAPH_TEMPLATE_PARMS, typename Tag>
|
|
typename property_map<BOOST_CSR_GRAPH_TYPE, Tag>::const_type
|
|
get(Tag tag, const BOOST_CSR_GRAPH_TYPE& g) {
|
|
return typename property_map<BOOST_CSR_GRAPH_TYPE, Tag>::const_type(tag, get(typename property_map<BOOST_CSR_GRAPH_TYPE, Tag>::all_tag(), g));
|
|
}
|
|
|
|
template <BOOST_CSR_GRAPH_TEMPLATE_PARMS, typename Tag>
|
|
typename property_traits<typename property_map<BOOST_CSR_GRAPH_TYPE, Tag>::type>::reference
|
|
get(Tag tag, BOOST_CSR_GRAPH_TYPE& g, typename property_map<BOOST_CSR_GRAPH_TYPE, Tag>::key_type k) {
|
|
typedef typename property_map<BOOST_CSR_GRAPH_TYPE, Tag>::all_tag all_tag;
|
|
typedef typename property_map<BOOST_CSR_GRAPH_TYPE, all_tag>::type outer_pm;
|
|
return lookup_one_property<typename property_traits<outer_pm>::value_type, Tag>::lookup(get(all_tag(), g, k), tag);
|
|
}
|
|
|
|
template <BOOST_CSR_GRAPH_TEMPLATE_PARMS, typename Tag>
|
|
typename property_traits<typename property_map<BOOST_CSR_GRAPH_TYPE, Tag>::const_type>::reference
|
|
get(Tag tag, const BOOST_CSR_GRAPH_TYPE& g, typename property_map<BOOST_CSR_GRAPH_TYPE, Tag>::key_type k) {
|
|
typedef typename property_map<BOOST_CSR_GRAPH_TYPE, Tag>::all_tag all_tag;
|
|
typedef typename property_map<BOOST_CSR_GRAPH_TYPE, all_tag>::const_type outer_pm;
|
|
return lookup_one_property<const typename property_traits<outer_pm>::value_type, Tag>::lookup(get(all_tag(), g, k), tag);
|
|
}
|
|
|
|
template <BOOST_CSR_GRAPH_TEMPLATE_PARMS, typename Tag>
|
|
void
|
|
put(Tag tag,
|
|
BOOST_CSR_GRAPH_TYPE& g,
|
|
typename property_map<BOOST_CSR_GRAPH_TYPE, Tag>::key_type k,
|
|
typename lookup_one_property<typename property_map<BOOST_CSR_GRAPH_TYPE, Tag>::plist_type, Tag>::type val) {
|
|
typedef typename property_map<BOOST_CSR_GRAPH_TYPE, Tag>::all_tag all_tag;
|
|
lookup_one_property<typename property_map<BOOST_CSR_GRAPH_TYPE, Tag>::plist_type, Tag>::lookup(get(all_tag(), g, k), tag) = val;
|
|
}
|
|
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
|
|
struct property_map<BOOST_CSR_GRAPH_TYPE, vertex_index_t, typename disable_if<detail::is_distributed_selector<Vertex> >::type>
|
|
{
|
|
typedef typed_identity_property_map<Vertex> type;
|
|
typedef type const_type;
|
|
};
|
|
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
|
|
struct property_map<BOOST_CSR_GRAPH_TYPE, edge_index_t, typename disable_if<detail::is_distributed_selector<Vertex> >::type>
|
|
{
|
|
typedef detail::csr_edge_index_map<Vertex, EdgeIndex> type;
|
|
typedef type const_type;
|
|
};
|
|
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
|
|
struct property_map<BOOST_CSR_GRAPH_TYPE, vertex_all_t, typename disable_if<detail::is_distributed_selector<Vertex> >::type>
|
|
{
|
|
typedef typename BOOST_CSR_GRAPH_TYPE::inherited_vertex_properties::vertex_map_type type;
|
|
typedef typename BOOST_CSR_GRAPH_TYPE::inherited_vertex_properties::const_vertex_map_type const_type;
|
|
};
|
|
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
|
|
struct property_map<BOOST_CSR_GRAPH_TYPE, edge_all_t, typename disable_if<detail::is_distributed_selector<Vertex> >::type>
|
|
{
|
|
typedef typename BOOST_CSR_GRAPH_TYPE::forward_type::inherited_edge_properties::edge_map_type type;
|
|
typedef typename BOOST_CSR_GRAPH_TYPE::forward_type::inherited_edge_properties::const_edge_map_type const_type;
|
|
};
|
|
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
|
|
struct property_map<BOOST_CSR_GRAPH_TYPE, graph_all_t, typename disable_if<detail::is_distributed_selector<Vertex> >::type>
|
|
{
|
|
typedef boost::ref_property_map<BOOST_CSR_GRAPH_TYPE*, typename BOOST_CSR_GRAPH_TYPE::graph_property_type> type;
|
|
typedef boost::ref_property_map<BOOST_CSR_GRAPH_TYPE*, const typename BOOST_CSR_GRAPH_TYPE::graph_property_type> const_type;
|
|
};
|
|
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
|
|
inline typed_identity_property_map<Vertex>
|
|
get(vertex_index_t, const BOOST_CSR_GRAPH_TYPE&)
|
|
{
|
|
return typed_identity_property_map<Vertex>();
|
|
}
|
|
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
|
|
inline Vertex
|
|
get(vertex_index_t,
|
|
const BOOST_CSR_GRAPH_TYPE&, Vertex v)
|
|
{
|
|
return v;
|
|
}
|
|
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
|
|
inline typed_identity_property_map<Vertex>
|
|
get(vertex_index_t, BOOST_CSR_GRAPH_TYPE&)
|
|
{
|
|
return typed_identity_property_map<Vertex>();
|
|
}
|
|
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
|
|
inline Vertex
|
|
get(vertex_index_t,
|
|
BOOST_CSR_GRAPH_TYPE&, Vertex v)
|
|
{
|
|
return v;
|
|
}
|
|
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
|
|
inline typename property_map<BOOST_CSR_GRAPH_TYPE, edge_index_t>::const_type
|
|
get(edge_index_t, const BOOST_CSR_GRAPH_TYPE&)
|
|
{
|
|
typedef typename property_map<BOOST_CSR_GRAPH_TYPE, edge_index_t>::const_type
|
|
result_type;
|
|
return result_type();
|
|
}
|
|
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
|
|
inline EdgeIndex
|
|
get(edge_index_t, const BOOST_CSR_GRAPH_TYPE&,
|
|
typename BOOST_CSR_GRAPH_TYPE::edge_descriptor e)
|
|
{
|
|
return e.idx;
|
|
}
|
|
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
|
|
inline typename property_map<BOOST_CSR_GRAPH_TYPE, edge_index_t>::const_type
|
|
get(edge_index_t, BOOST_CSR_GRAPH_TYPE&)
|
|
{
|
|
typedef typename property_map<BOOST_CSR_GRAPH_TYPE, edge_index_t>::const_type
|
|
result_type;
|
|
return result_type();
|
|
}
|
|
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
|
|
inline EdgeIndex
|
|
get(edge_index_t, BOOST_CSR_GRAPH_TYPE&,
|
|
typename BOOST_CSR_GRAPH_TYPE::edge_descriptor e)
|
|
{
|
|
return e.idx;
|
|
}
|
|
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
|
|
inline typename property_map<BOOST_CSR_GRAPH_TYPE, vertex_all_t>::type
|
|
get(vertex_all_t, BOOST_CSR_GRAPH_TYPE& g)
|
|
{
|
|
return g.get_vertex_bundle(get(vertex_index, g));
|
|
}
|
|
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
|
|
inline typename property_map<BOOST_CSR_GRAPH_TYPE, vertex_all_t>::const_type
|
|
get(vertex_all_t, const BOOST_CSR_GRAPH_TYPE& g)
|
|
{
|
|
return g.get_vertex_bundle(get(vertex_index, g));
|
|
}
|
|
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
|
|
inline VertexProperty&
|
|
get(vertex_all_t,
|
|
BOOST_CSR_GRAPH_TYPE& g, Vertex v)
|
|
{
|
|
return get(vertex_all, g)[v];
|
|
}
|
|
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
|
|
inline const VertexProperty&
|
|
get(vertex_all_t,
|
|
const BOOST_CSR_GRAPH_TYPE& g, Vertex v)
|
|
{
|
|
return get(vertex_all, g)[v];
|
|
}
|
|
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
|
|
inline void
|
|
put(vertex_all_t,
|
|
BOOST_CSR_GRAPH_TYPE& g,
|
|
Vertex v,
|
|
const VertexProperty& val)
|
|
{
|
|
put(get(vertex_all, g), v, val);
|
|
}
|
|
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
|
|
inline typename property_map<BOOST_CSR_GRAPH_TYPE, edge_all_t>::type
|
|
get(edge_all_t, BOOST_CSR_GRAPH_TYPE& g)
|
|
{
|
|
return g.m_forward.get_edge_bundle(get(edge_index, g));
|
|
}
|
|
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
|
|
inline typename property_map<BOOST_CSR_GRAPH_TYPE, edge_all_t>::const_type
|
|
get(edge_all_t, const BOOST_CSR_GRAPH_TYPE& g)
|
|
{
|
|
return g.m_forward.get_edge_bundle(get(edge_index, g));
|
|
}
|
|
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
|
|
inline EdgeProperty&
|
|
get(edge_all_t,
|
|
BOOST_CSR_GRAPH_TYPE& g,
|
|
const typename BOOST_CSR_GRAPH_TYPE::edge_descriptor& e)
|
|
{
|
|
return get(edge_all, g)[e];
|
|
}
|
|
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
|
|
inline const EdgeProperty&
|
|
get(edge_all_t,
|
|
const BOOST_CSR_GRAPH_TYPE& g,
|
|
const typename BOOST_CSR_GRAPH_TYPE::edge_descriptor& e)
|
|
{
|
|
return get(edge_all, g)[e];
|
|
}
|
|
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
|
|
inline void
|
|
put(edge_all_t,
|
|
BOOST_CSR_GRAPH_TYPE& g,
|
|
const typename BOOST_CSR_GRAPH_TYPE::edge_descriptor& e,
|
|
const EdgeProperty& val)
|
|
{
|
|
put(get(edge_all, g), e, val);
|
|
}
|
|
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
|
|
inline typename property_map<BOOST_CSR_GRAPH_TYPE, graph_all_t>::type
|
|
get(graph_all_t, BOOST_CSR_GRAPH_TYPE& g)
|
|
{
|
|
return typename property_map<BOOST_CSR_GRAPH_TYPE, graph_all_t>::type(g.m_property);
|
|
}
|
|
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
|
|
inline typename property_map<BOOST_CSR_GRAPH_TYPE, graph_all_t>::const_type
|
|
get(graph_all_t, const BOOST_CSR_GRAPH_TYPE& g)
|
|
{
|
|
return typename property_map<BOOST_CSR_GRAPH_TYPE, graph_all_t>::const_type(g.m_property);
|
|
}
|
|
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
|
|
inline GraphProperty&
|
|
get(graph_all_t,
|
|
BOOST_CSR_GRAPH_TYPE& g,
|
|
BOOST_CSR_GRAPH_TYPE*)
|
|
{
|
|
return g.m_property;
|
|
}
|
|
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
|
|
inline const GraphProperty&
|
|
get(graph_all_t,
|
|
const BOOST_CSR_GRAPH_TYPE& g,
|
|
BOOST_CSR_GRAPH_TYPE*)
|
|
{
|
|
return g.m_property;
|
|
}
|
|
|
|
template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
|
|
inline void
|
|
put(graph_all_t,
|
|
BOOST_CSR_GRAPH_TYPE& g,
|
|
BOOST_CSR_GRAPH_TYPE*,
|
|
const GraphProperty& val)
|
|
{
|
|
g.m_property = val;
|
|
}
|
|
|
|
#undef BOOST_CSR_GRAPH_TYPE
|
|
#undef BOOST_CSR_GRAPH_TEMPLATE_PARMS
|
|
#undef BOOST_DIR_CSR_GRAPH_TYPE
|
|
#undef BOOST_DIR_CSR_GRAPH_TEMPLATE_PARMS
|
|
#undef BOOST_BIDIR_CSR_GRAPH_TYPE
|
|
#undef BOOST_BIDIR_CSR_GRAPH_TEMPLATE_PARMS
|
|
|
|
} // end namespace boost
|
|
|
|
#endif // BOOST_GRAPH_COMPRESSED_SPARSE_ROW_GRAPH_HPP
|