Added boost header

test/external/boost/graph/vector_as_graph.hpp

@@ -0,0 +1,332 @@
+//=======================================================================
+// 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/range/irange.hpp>
+#include <boost/graph/graph_traits.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