#ifndef BOOST_GRAPH_ADJACENCY_LIST_HPP
#define BOOST_GRAPH_ADJACENCY_LIST_HPP
-
#include <boost/config.hpp>
#include <vector>
#include <boost/graph/properties.hpp>
#include <boost/graph/named_graph.hpp>
-namespace boost {
-
- //===========================================================================
- // Selectors for the VertexList and EdgeList template parameters of
- // adjacency_list, and the container_gen traits class which is used
- // to map the selectors to the container type used to implement the
- // graph.
-
- struct vecS { };
- struct listS { };
- struct setS { };
- struct mapS { };
- struct multisetS { };
- struct multimapS { };
- struct hash_setS { };
- struct hash_mapS { };
- struct hash_multisetS { };
- struct hash_multimapS { };
-
- template <class Selector, class ValueType>
- struct container_gen { };
-
- template <class ValueType>
- struct container_gen<listS, ValueType> {
- typedef std::list<ValueType> type;
- };
-
- template <class ValueType>
- struct container_gen<vecS, ValueType> {
- typedef std::vector<ValueType> type;
- };
-
- template <class ValueType>
- struct container_gen<mapS, ValueType> {
- typedef std::set<ValueType> type;
- };
-
- template <class ValueType>
- struct container_gen<setS, ValueType> {
- typedef std::set<ValueType> type;
- };
-
- template <class ValueType>
- struct container_gen<multisetS, ValueType> {
- typedef std::multiset<ValueType> type;
- };
-
- template <class ValueType>
- struct container_gen<multimapS, ValueType> {
- typedef std::multiset<ValueType> type;
- };
-
- template <class ValueType>
- struct container_gen<hash_setS, ValueType> {
- typedef boost::unordered_set<ValueType> type;
- };
-
- template <class ValueType>
- struct container_gen<hash_mapS, ValueType> {
- typedef boost::unordered_set<ValueType> type;
- };
-
- template <class ValueType>
- struct container_gen<hash_multisetS, ValueType> {
- typedef boost::unordered_multiset<ValueType> type;
- };
-
- template <class ValueType>
- struct container_gen<hash_multimapS, ValueType> {
- typedef boost::unordered_multiset<ValueType> type;
- };
-
- template <class StorageSelector>
- struct parallel_edge_traits { };
-
- template <>
- struct parallel_edge_traits<vecS> {
- typedef allow_parallel_edge_tag type; };
-
- template <>
- struct parallel_edge_traits<listS> {
- typedef allow_parallel_edge_tag type; };
-
- template <>
- struct parallel_edge_traits<setS> {
- typedef disallow_parallel_edge_tag type; };
-
- template <>
- struct parallel_edge_traits<multisetS> {
- typedef allow_parallel_edge_tag type; };
-
- template <>
- struct parallel_edge_traits<hash_setS> {
+namespace boost
+{
+
+//===========================================================================
+// Selectors for the VertexList and EdgeList template parameters of
+// adjacency_list, and the container_gen traits class which is used
+// to map the selectors to the container type used to implement the
+// graph.
+
+struct vecS
+{
+};
+struct listS
+{
+};
+struct setS
+{
+};
+struct mapS
+{
+};
+struct multisetS
+{
+};
+struct multimapS
+{
+};
+struct hash_setS
+{
+};
+struct hash_mapS
+{
+};
+struct hash_multisetS
+{
+};
+struct hash_multimapS
+{
+};
+
+template < class Selector, class ValueType > struct container_gen
+{
+};
+
+template < class ValueType > struct container_gen< listS, ValueType >
+{
+ typedef std::list< ValueType > type;
+};
+
+template < class ValueType > struct container_gen< vecS, ValueType >
+{
+ typedef std::vector< ValueType > type;
+};
+
+template < class ValueType > struct container_gen< mapS, ValueType >
+{
+ typedef std::set< ValueType > type;
+};
+
+template < class ValueType > struct container_gen< setS, ValueType >
+{
+ typedef std::set< ValueType > type;
+};
+
+template < class ValueType > struct container_gen< multisetS, ValueType >
+{
+ typedef std::multiset< ValueType > type;
+};
+
+template < class ValueType > struct container_gen< multimapS, ValueType >
+{
+ typedef std::multiset< ValueType > type;
+};
+
+template < class ValueType > struct container_gen< hash_setS, ValueType >
+{
+ typedef boost::unordered_set< ValueType > type;
+};
+
+template < class ValueType > struct container_gen< hash_mapS, ValueType >
+{
+ typedef boost::unordered_set< ValueType > type;
+};
+
+template < class ValueType > struct container_gen< hash_multisetS, ValueType >
+{
+ typedef boost::unordered_multiset< ValueType > type;
+};
+
+template < class ValueType > struct container_gen< hash_multimapS, ValueType >
+{
+ typedef boost::unordered_multiset< ValueType > type;
+};
+
+template < class StorageSelector > struct parallel_edge_traits
+{
+};
+
+template <> struct parallel_edge_traits< vecS >
+{
+ typedef allow_parallel_edge_tag type;
+};
+
+template <> struct parallel_edge_traits< listS >
+{
+ typedef allow_parallel_edge_tag type;
+};
+
+template <> struct parallel_edge_traits< setS >
+{
+ typedef disallow_parallel_edge_tag type;
+};
+
+template <> struct parallel_edge_traits< multisetS >
+{
+ typedef allow_parallel_edge_tag type;
+};
+
+template <> struct parallel_edge_traits< hash_setS >
+{
typedef disallow_parallel_edge_tag type;
- };
+};
- // mapS is obsolete, replaced with setS
- template <>
- struct parallel_edge_traits<mapS> {
- typedef disallow_parallel_edge_tag type; };
+// mapS is obsolete, replaced with setS
+template <> struct parallel_edge_traits< mapS >
+{
+ typedef disallow_parallel_edge_tag type;
+};
- template <>
- struct parallel_edge_traits<hash_mapS> {
+template <> struct parallel_edge_traits< hash_mapS >
+{
typedef disallow_parallel_edge_tag type;
- };
+};
- template <>
- struct parallel_edge_traits<hash_multisetS> {
+template <> struct parallel_edge_traits< hash_multisetS >
+{
typedef allow_parallel_edge_tag type;
- };
+};
- template <>
- struct parallel_edge_traits<hash_multimapS> {
+template <> struct parallel_edge_traits< hash_multimapS >
+{
typedef allow_parallel_edge_tag type;
- };
+};
- namespace detail {
- template <class Directed> struct is_random_access {
- enum { value = false};
- typedef mpl::false_ type;
+namespace detail
+{
+ template < class Directed > struct is_random_access
+ {
+ enum
+ {
+ value = false
+ };
+ typedef mpl::false_ type;
};
- template <>
- struct is_random_access<vecS> {
- enum { value = true };
- typedef mpl::true_ type;
+ template <> struct is_random_access< vecS >
+ {
+ enum
+ {
+ value = true
+ };
+ typedef mpl::true_ type;
};
- } // namespace detail
-
- template <typename Selector> struct is_distributed_selector: mpl::false_ {};
-
+} // namespace detail
- //===========================================================================
- // The adjacency_list_traits class, which provides a way to access
- // some of the associated types of an adjacency_list type without
- // having to first create the adjacency_list type. This is useful
- // when trying to create interior vertex or edge properties who's
- // value type is a vertex or edge descriptor.
+template < typename Selector > struct is_distributed_selector : mpl::false_
+{
+};
- template <class OutEdgeListS = vecS,
- class VertexListS = vecS,
- class DirectedS = directedS,
- class EdgeListS = listS>
- struct adjacency_list_traits
- {
- typedef typename detail::is_random_access<VertexListS>::type
- is_rand_access;
+//===========================================================================
+// The adjacency_list_traits class, which provides a way to access
+// some of the associated types of an adjacency_list type without
+// having to first create the adjacency_list type. This is useful
+// when trying to create interior vertex or edge properties who's
+// value type is a vertex or edge descriptor.
+
+template < class OutEdgeListS = vecS, class VertexListS = vecS,
+ class DirectedS = directedS, class EdgeListS = listS >
+struct adjacency_list_traits
+{
+ typedef
+ typename detail::is_random_access< VertexListS >::type is_rand_access;
typedef typename DirectedS::is_bidir_t is_bidir;
typedef typename DirectedS::is_directed_t is_directed;
- typedef typename mpl::if_<is_bidir,
- bidirectional_tag,
- typename mpl::if_<is_directed,
- directed_tag, undirected_tag
- >::type
- >::type directed_category;
+ typedef typename mpl::if_< is_bidir, bidirectional_tag,
+ typename mpl::if_< is_directed, directed_tag,
+ undirected_tag >::type >::type directed_category;
- typedef typename parallel_edge_traits<OutEdgeListS>::type
- edge_parallel_category;
+ typedef typename parallel_edge_traits< OutEdgeListS >::type
+ edge_parallel_category;
typedef std::size_t vertices_size_type;
typedef void* vertex_ptr;
- typedef typename mpl::if_<is_rand_access,
- vertices_size_type, vertex_ptr>::type vertex_descriptor;
- typedef detail::edge_desc_impl<directed_category, vertex_descriptor>
- edge_descriptor;
+ typedef typename mpl::if_< is_rand_access, vertices_size_type,
+ vertex_ptr >::type vertex_descriptor;
+ typedef detail::edge_desc_impl< directed_category, vertex_descriptor >
+ edge_descriptor;
- private:
+private:
// Logic to figure out the edges_size_type
- struct dummy {};
- typedef typename container_gen<EdgeListS, dummy>::type EdgeContainer;
+ struct dummy
+ {
+ };
+ typedef typename container_gen< EdgeListS, dummy >::type EdgeContainer;
typedef typename DirectedS::is_bidir_t BidirectionalT;
typedef typename DirectedS::is_directed_t DirectedT;
- typedef typename mpl::and_<DirectedT,
- typename mpl::not_<BidirectionalT>::type >::type on_edge_storage;
- public:
- typedef typename mpl::if_<on_edge_storage,
- std::size_t, typename EdgeContainer::size_type
- >::type edges_size_type;
+ typedef typename mpl::and_< DirectedT,
+ typename mpl::not_< BidirectionalT >::type >::type on_edge_storage;
- };
+public:
+ typedef typename mpl::if_< on_edge_storage, std::size_t,
+ typename EdgeContainer::size_type >::type edges_size_type;
+};
} // namespace boost
#include <boost/graph/detail/adjacency_list.hpp>
-namespace boost {
-
- //===========================================================================
- // The adjacency_list class.
- //
-
- template <class OutEdgeListS = vecS, // a Sequence or an AssociativeContainer
- class VertexListS = vecS, // a Sequence or a RandomAccessContainer
- class DirectedS = directedS,
- class VertexProperty = no_property,
- class EdgeProperty = no_property,
- class GraphProperty = no_property,
- class EdgeListS = listS>
- class adjacency_list
- : public detail::adj_list_gen<
- adjacency_list<OutEdgeListS,VertexListS,DirectedS,
- VertexProperty,EdgeProperty,GraphProperty,EdgeListS>,
- VertexListS, OutEdgeListS, DirectedS,
- VertexProperty, EdgeProperty,
- GraphProperty, EdgeListS>::type,
- // Support for named vertices
- public graph::maybe_named_graph<
- adjacency_list<OutEdgeListS,VertexListS,DirectedS,
- VertexProperty,EdgeProperty,GraphProperty,EdgeListS>,
- typename adjacency_list_traits<OutEdgeListS, VertexListS, DirectedS,
- EdgeListS>::vertex_descriptor,
- VertexProperty>
- {
- public:
+namespace boost
+{
+
+//===========================================================================
+// The adjacency_list class.
+//
+
+template < class OutEdgeListS = vecS, // a Sequence or an AssociativeContainer
+ class VertexListS = vecS, // a Sequence or a RandomAccessContainer
+ class DirectedS = directedS, class VertexProperty = no_property,
+ class EdgeProperty = no_property, class GraphProperty = no_property,
+ class EdgeListS = listS >
+class adjacency_list
+: public detail::adj_list_gen<
+ adjacency_list< OutEdgeListS, VertexListS, DirectedS, VertexProperty,
+ EdgeProperty, GraphProperty, EdgeListS >,
+ VertexListS, OutEdgeListS, DirectedS, VertexProperty, EdgeProperty,
+ GraphProperty, EdgeListS >::type,
+ // Support for named vertices
+ public graph::maybe_named_graph<
+ adjacency_list< OutEdgeListS, VertexListS, DirectedS, VertexProperty,
+ EdgeProperty, GraphProperty, EdgeListS >,
+ typename adjacency_list_traits< OutEdgeListS, VertexListS, DirectedS,
+ EdgeListS >::vertex_descriptor,
+ VertexProperty >
+{
+public:
typedef GraphProperty graph_property_type;
- typedef typename lookup_one_property<GraphProperty, graph_bundle_t>::type graph_bundled;
+ typedef typename lookup_one_property< GraphProperty, graph_bundle_t >::type
+ graph_bundled;
typedef VertexProperty vertex_property_type;
- typedef typename lookup_one_property<VertexProperty, vertex_bundle_t>::type vertex_bundled;
+ typedef
+ typename lookup_one_property< VertexProperty, vertex_bundle_t >::type
+ vertex_bundled;
typedef EdgeProperty edge_property_type;
- typedef typename lookup_one_property<EdgeProperty, edge_bundle_t>::type edge_bundled;
+ typedef typename lookup_one_property< EdgeProperty, edge_bundle_t >::type
+ edge_bundled;
- private:
+private:
typedef adjacency_list self;
- typedef typename detail::adj_list_gen<
- self, VertexListS, OutEdgeListS, DirectedS,
- vertex_property_type, edge_property_type, GraphProperty, EdgeListS
- >::type Base;
+ typedef typename detail::adj_list_gen< self, VertexListS, OutEdgeListS,
+ DirectedS, vertex_property_type, edge_property_type, GraphProperty,
+ EdgeListS >::type Base;
- public:
+public:
typedef typename Base::stored_vertex stored_vertex;
typedef typename Base::vertices_size_type vertices_size_type;
typedef typename Base::edges_size_type edges_size_type;
typedef DirectedS directed_selector;
typedef EdgeListS edge_list_selector;
-
adjacency_list(const GraphProperty& p = GraphProperty())
- : m_property(new graph_property_type(p))
- { }
+ : m_property(new graph_property_type(p))
+ {
+ }
adjacency_list(const adjacency_list& x)
- : Base(x), m_property(new graph_property_type(*x.m_property))
- { }
-
- adjacency_list& operator=(const adjacency_list& x) {
- // TBD: probably should give the strong guarantee
- if (&x != this) {
- Base::operator=(x);
-
- // Copy/swap the ptr since we can't just assign it...
- property_ptr p(new graph_property_type(*x.m_property));
- m_property.swap(p);
- }
- return *this;
+ : Base(x), m_property(new graph_property_type(*x.m_property))
+ {
+ }
+
+ adjacency_list& operator=(const adjacency_list& x)
+ {
+ // TBD: probably should give the strong guarantee
+ if (&x != this)
+ {
+ Base::operator=(x);
+
+ // Copy/swap the ptr since we can't just assign it...
+ property_ptr p(new graph_property_type(*x.m_property));
+ m_property.swap(p);
+ }
+ return *this;
}
// Required by Mutable Graph
adjacency_list(vertices_size_type num_vertices,
- const GraphProperty& p = GraphProperty())
- : Base(num_vertices), m_property(new graph_property_type(p))
- { }
+ const GraphProperty& p = GraphProperty())
+ : Base(num_vertices), m_property(new graph_property_type(p))
+ {
+ }
// Required by Iterator Constructible Graph
- template <class EdgeIterator>
- adjacency_list(EdgeIterator first, EdgeIterator last,
- vertices_size_type n,
- edges_size_type = 0,
- const GraphProperty& p = GraphProperty())
- : Base(n, first, last), m_property(new graph_property_type(p))
- { }
+ template < class EdgeIterator >
+ adjacency_list(EdgeIterator first, EdgeIterator last, vertices_size_type n,
+ edges_size_type = 0, const GraphProperty& p = GraphProperty())
+ : Base(n, first, last), m_property(new graph_property_type(p))
+ {
+ }
- template <class EdgeIterator, class EdgePropertyIterator>
+ template < class EdgeIterator, class EdgePropertyIterator >
adjacency_list(EdgeIterator first, EdgeIterator last,
- EdgePropertyIterator ep_iter,
- vertices_size_type n,
- edges_size_type = 0,
- const GraphProperty& p = GraphProperty())
- : Base(n, first, last, ep_iter), m_property(new graph_property_type(p))
- { }
-
- void swap(adjacency_list& x) {
- // Is there a more efficient way to do this?
- adjacency_list tmp(x);
- x = *this;
- *this = tmp;
+ EdgePropertyIterator ep_iter, vertices_size_type n, edges_size_type = 0,
+ const GraphProperty& p = GraphProperty())
+ : Base(n, first, last, ep_iter), m_property(new graph_property_type(p))
+ {
+ }
+
+ void swap(adjacency_list& x)
+ {
+ // Is there a more efficient way to do this?
+ adjacency_list tmp(x);
+ x = *this;
+ *this = tmp;
}
void clear()
{
- this->clearing_graph();
- Base::clear();
+ this->clearing_graph();
+ Base::clear();
}
#ifndef BOOST_GRAPH_NO_BUNDLED_PROPERTIES
// Directly access a vertex or edge bundle
vertex_bundled& operator[](vertex_descriptor v)
- { return get(vertex_bundle, *this)[v]; }
+ {
+ return get(vertex_bundle, *this)[v];
+ }
const vertex_bundled& operator[](vertex_descriptor v) const
- { return get(vertex_bundle, *this)[v]; }
+ {
+ return get(vertex_bundle, *this)[v];
+ }
edge_bundled& operator[](edge_descriptor e)
- { return get(edge_bundle, *this)[e]; }
+ {
+ return get(edge_bundle, *this)[e];
+ }
const edge_bundled& operator[](edge_descriptor e) const
- { return get(edge_bundle, *this)[e]; }
+ {
+ return get(edge_bundle, *this)[e];
+ }
- graph_bundled& operator[](graph_bundle_t)
- { return get_property(*this); }
+ graph_bundled& operator[](graph_bundle_t) { return get_property(*this); }
graph_bundled const& operator[](graph_bundle_t) const
- { return get_property(*this); }
+ {
+ return get_property(*this);
+ }
#endif
// protected: (would be protected if friends were more portable)
- typedef scoped_ptr<graph_property_type> property_ptr;
- property_ptr m_property;
- };
+ typedef scoped_ptr< graph_property_type > property_ptr;
+ property_ptr m_property;
+};
-#define ADJLIST_PARAMS \
+#define ADJLIST_PARAMS \
typename OEL, typename VL, typename D, typename VP, typename EP, \
- typename GP, typename EL
-#define ADJLIST adjacency_list<OEL,VL,D,VP,EP,GP,EL>
+ typename GP, typename EL
+#define ADJLIST adjacency_list< OEL, VL, D, VP, EP, GP, EL >
- template<ADJLIST_PARAMS, typename Tag, typename Value>
- inline void set_property(ADJLIST& g, Tag tag, Value const& value) {
+template < ADJLIST_PARAMS, typename Tag, typename Value >
+inline void set_property(ADJLIST& g, Tag tag, Value const& value)
+{
get_property_value(*g.m_property, tag) = value;
- }
+}
- template<ADJLIST_PARAMS, typename Tag>
- inline typename graph_property<ADJLIST, Tag>::type&
- get_property(ADJLIST& g, Tag tag) {
+template < ADJLIST_PARAMS, typename Tag >
+inline typename graph_property< ADJLIST, Tag >::type& get_property(
+ ADJLIST& g, Tag tag)
+{
return get_property_value(*g.m_property, tag);
- }
+}
- template<ADJLIST_PARAMS, typename Tag>
- inline typename graph_property<ADJLIST, Tag>::type const&
- get_property(ADJLIST const& g, Tag tag) {
+template < ADJLIST_PARAMS, typename Tag >
+inline typename graph_property< ADJLIST, Tag >::type const& get_property(
+ ADJLIST const& g, Tag tag)
+{
return get_property_value(*g.m_property, tag);
- }
-
- // dwa 09/25/00 - needed to be more explicit so reverse_graph would work.
- template <class Directed, class Vertex,
- class OutEdgeListS,
- class VertexListS,
- class DirectedS,
- class VertexProperty,
- class EdgeProperty,
- class GraphProperty, class EdgeListS>
- inline Vertex
- source(const detail::edge_base<Directed,Vertex>& e,
- const adjacency_list<OutEdgeListS, VertexListS, DirectedS,
- VertexProperty, EdgeProperty, GraphProperty, EdgeListS>&)
- {
+}
+
+// dwa 09/25/00 - needed to be more explicit so reverse_graph would work.
+template < class Directed, class Vertex, class OutEdgeListS, class VertexListS,
+ class DirectedS, class VertexProperty, class EdgeProperty,
+ class GraphProperty, class EdgeListS >
+inline Vertex source(const detail::edge_base< Directed, Vertex >& e,
+ const adjacency_list< OutEdgeListS, VertexListS, DirectedS, VertexProperty,
+ EdgeProperty, GraphProperty, EdgeListS >&)
+{
return e.m_source;
- }
-
- template <class Directed, class Vertex, class OutEdgeListS,
- class VertexListS, class DirectedS, class VertexProperty,
- class EdgeProperty, class GraphProperty, class EdgeListS>
- inline Vertex
- target(const detail::edge_base<Directed,Vertex>& e,
- const adjacency_list<OutEdgeListS, VertexListS, DirectedS,
- VertexProperty, EdgeProperty, GraphProperty, EdgeListS>&)
- {
+}
+
+template < class Directed, class Vertex, class OutEdgeListS, class VertexListS,
+ class DirectedS, class VertexProperty, class EdgeProperty,
+ class GraphProperty, class EdgeListS >
+inline Vertex target(const detail::edge_base< Directed, Vertex >& e,
+ const adjacency_list< OutEdgeListS, VertexListS, DirectedS, VertexProperty,
+ EdgeProperty, GraphProperty, EdgeListS >&)
+{
return e.m_target;
- }
+}
// Mutability Traits
-template <ADJLIST_PARAMS>
-struct graph_mutability_traits<ADJLIST> {
+template < ADJLIST_PARAMS > struct graph_mutability_traits< ADJLIST >
+{
typedef mutable_property_graph_tag category;
};
// Can't remove vertices from adjacency lists with VL==vecS
-template <typename OEL, typename D, typename VP, typename EP, typename GP, typename EL>
-struct graph_mutability_traits< adjacency_list<OEL,vecS,D,VP,EP,GP,EL> > {
+template < typename OEL, typename D, typename VP, typename EP, typename GP,
+ typename EL >
+struct graph_mutability_traits< adjacency_list< OEL, vecS, D, VP, EP, GP, EL > >
+{
typedef add_only_property_graph_tag category;
};
#undef ADJLIST_PARAMS
#undef ADJLIST
-
} // namespace boost
-
#endif // BOOST_GRAPH_ADJACENCY_LIST_HPP
projects / ceph.git / blobdiff