boost/graph/vector_as_graph.hpp
//======================================================================= // Copyright 1997, 1998, 1999, 2000 University of Notre Dame. // Copyright 2006 The Trustees of Indiana University. // Copyright (C) 2001 Vladimir Prus <ghost@cs.msu.su> // Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek, Douglas Gregor // // 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) //======================================================================= // The mutating functions (add_edge, etc.) were added by Vladimir Prus. #ifndef BOOST_VECTOR_AS_GRAPH_HPP #define BOOST_VECTOR_AS_GRAPH_HPP #include <cassert> #include <utility> #include <vector> #include <cstddef> #include <boost/iterator.hpp> #include <boost/graph/graph_traits.hpp> #include <boost/pending/integer_range.hpp> #include <boost/property_map/property_map.hpp> #include <boost/graph/properties.hpp> #include <algorithm> /* This module implements the VertexListGraph concept using a std::vector as the "back-bone" of the graph (the vector *is* the graph object). The edge-lists type of the graph is templated, so the user can choose any STL container, so long as the value_type of the container is convertible to the size_type of the vector. For now any graph properties must be stored seperately. This module requires the C++ compiler to support partial specialization for the graph_traits class, so this is not portable to VC++. */ #ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION #error The vector-as-graph module requires a compiler that supports partial specialization #endif namespace boost { namespace detail { template <class EdgeList> struct val_out_edge_ret; template <class EdgeList> struct val_out_edge_iter; template <class EdgeList> struct val_edge; } } #if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION namespace boost { struct vector_as_graph_traversal_tag : public vertex_list_graph_tag, public adjacency_graph_tag, public incidence_graph_tag { }; template <class EdgeList> struct graph_traits< std::vector<EdgeList> > { typedef typename EdgeList::value_type V; typedef V vertex_descriptor; typedef typename detail::val_edge<EdgeList>::type edge_descriptor; typedef typename EdgeList::const_iterator adjacency_iterator; typedef typename detail::val_out_edge_iter<EdgeList>::type out_edge_iterator; typedef void in_edge_iterator; typedef void edge_iterator; typedef typename integer_range<V>::iterator vertex_iterator; typedef directed_tag directed_category; typedef allow_parallel_edge_tag edge_parallel_category; typedef vector_as_graph_traversal_tag traversal_category; typedef typename std::vector<EdgeList>::size_type vertices_size_type; typedef void edges_size_type; typedef typename EdgeList::size_type degree_size_type; }; template <class EdgeList> struct edge_property_type< std::vector<EdgeList> > { typedef void type; }; template <class EdgeList> struct vertex_property_type< std::vector<EdgeList> > { typedef void type; }; template <class EdgeList> struct graph_property_type< std::vector<EdgeList> > { typedef void type; }; } #endif namespace boost { namespace detail { // "val" is short for Vector Adjacency List template <class EdgeList> struct val_edge { typedef typename EdgeList::value_type V; typedef std::pair<V,V> type; }; // need rewrite this using boost::iterator_adaptor template <class V, class Iter> class val_out_edge_iterator : public boost::iterator<std::input_iterator_tag, std::pair<V,V>, std::ptrdiff_t, std::pair<V,V>*, const std::pair<V,V> > { typedef val_out_edge_iterator self; typedef std::pair<V,V> Edge; public: val_out_edge_iterator() { } val_out_edge_iterator(V s, Iter i) : _source(s), _iter(i) { } Edge operator*() const { return Edge(_source, *_iter); } self& operator++() { ++_iter; return *this; } self operator++(int) { self t = *this; ++_iter; return t; } bool operator==(const self& x) const { return _iter == x._iter; } bool operator!=(const self& x) const { return _iter != x._iter; } protected: V _source; Iter _iter; }; template <class EdgeList> struct val_out_edge_iter { typedef typename EdgeList::value_type V; typedef typename EdgeList::const_iterator Iter; typedef val_out_edge_iterator<V,Iter> type; }; template <class EdgeList> struct val_out_edge_ret { typedef typename val_out_edge_iter<EdgeList>::type IncIter; typedef std::pair<IncIter,IncIter> type; }; } // namesapce detail template <class EdgeList, class Alloc> typename detail::val_out_edge_ret<EdgeList>::type out_edges(typename EdgeList::value_type v, const std::vector<EdgeList, Alloc>& g) { typedef typename detail::val_out_edge_iter<EdgeList>::type Iter; typedef typename detail::val_out_edge_ret<EdgeList>::type return_type; return return_type(Iter(v, g[v].begin()), Iter(v, g[v].end())); } template <class EdgeList, class Alloc> typename EdgeList::size_type out_degree(typename EdgeList::value_type v, const std::vector<EdgeList, Alloc>& g) { return g[v].size(); } template <class EdgeList, class Alloc> std::pair<typename EdgeList::const_iterator, typename EdgeList::const_iterator> adjacent_vertices(typename EdgeList::value_type v, const std::vector<EdgeList, Alloc>& g) { return std::make_pair(g[v].begin(), g[v].end()); } // source() and target() already provided for pairs in graph_traits.hpp template <class EdgeList, class Alloc> std::pair<typename boost::integer_range<typename EdgeList::value_type> ::iterator, typename boost::integer_range<typename EdgeList::value_type> ::iterator > vertices(const std::vector<EdgeList, Alloc>& v) { typedef typename boost::integer_range<typename EdgeList::value_type> ::iterator Iter; return std::make_pair(Iter(0), Iter(v.size())); } template <class EdgeList, class Alloc> typename std::vector<EdgeList, Alloc>::size_type num_vertices(const std::vector<EdgeList, Alloc>& v) { return v.size(); } template<class EdgeList, class Allocator> typename std::pair<typename detail::val_edge<EdgeList>::type, bool> add_edge(typename EdgeList::value_type u, typename EdgeList::value_type v, std::vector<EdgeList, Allocator>& g) { typedef typename detail::val_edge<EdgeList>::type edge_type; g[u].insert(g[u].end(), v); return std::make_pair(edge_type(u, v), true); } template<class EdgeList, class Allocator> typename std::pair<typename detail::val_edge<EdgeList>::type, bool> edge(typename EdgeList::value_type u, typename EdgeList::value_type v, std::vector<EdgeList, Allocator>& g) { typedef typename detail::val_edge<EdgeList>::type edge_type; typename EdgeList::iterator i = g[u].begin(), end = g[u].end(); for (; i != end; ++i) if (*i == v) return std::make_pair(edge_type(u, v), true); return std::make_pair(edge_type(), false); } template<class EdgeList, class Allocator> void remove_edge(typename EdgeList::value_type u, typename EdgeList::value_type v, std::vector<EdgeList, Allocator>& g) { typename EdgeList::iterator i = std::remove(g[u].begin(), g[u].end(), v); if (i != g[u].end()) g[u].erase(i, g[u].end()); } template<class EdgeList, class Allocator> void remove_edge(typename detail::val_edge<EdgeList>::type e, std::vector<EdgeList, Allocator>& g) { typename EdgeList::value_type u, v; u = e.first; v = e.second; // FIXME: edge type does not fully specify the edge to be deleted typename EdgeList::iterator i = std::remove(g[u].begin(), g[u].end(), v); if (i != g[u].end()) g[u].erase(i, g[u].end()); } template<class EdgeList, class Allocator, class Predicate> void remove_edge_if(Predicate p, std::vector<EdgeList, Allocator>& g) { for (std::size_t u = 0; u < g.size(); ++u) { // Oops! gcc gets internal compiler error on compose_....... typedef typename EdgeList::iterator iterator; iterator b = g[u].begin(), e = g[u].end(); if (!g[u].empty()) { for(; b != e;) { if (p(std::make_pair(u, *b))) { --e; if (b == e) break; else iter_swap(b, e); } else { ++b; } } } if (e != g[u].end()) g[u].erase(e, g[u].end()); } } template<class EdgeList, class Allocator> typename EdgeList::value_type add_vertex(std::vector<EdgeList, Allocator>& g) { g.resize(g.size()+1); return g.size()-1; } template<class EdgeList, class Allocator> void clear_vertex(typename EdgeList::value_type u, std::vector<EdgeList, Allocator>& g) { g[u].clear(); for (std::size_t i = 0; i < g.size(); ++i) remove_edge(i, u, g); } template<class EdgeList, class Allocator> void remove_vertex(typename EdgeList::value_type u, std::vector<EdgeList, Allocator>& g) { typedef typename EdgeList::iterator iterator; clear_vertex(u, g); g.erase(g.begin() + u); for (std::size_t i = 0; i < g.size(); ++i) for ( iterator it = g[i].begin(); it != g[i].end(); ++it ) // after clear_vertex *it is never equal to u if ( *it > u ) --*it; } template<typename EdgeList, typename Allocator> struct property_map<std::vector<EdgeList, Allocator>, vertex_index_t> { typedef identity_property_map type; typedef type const_type; }; template<typename EdgeList, typename Allocator> identity_property_map get(vertex_index_t, const std::vector<EdgeList, Allocator>&) { return identity_property_map(); } template<typename EdgeList, typename Allocator> identity_property_map get(vertex_index_t, std::vector<EdgeList, Allocator>&) { return identity_property_map(); } } // namespace boost #endif // BOOST_VECTOR_AS_GRAPH_HPP