Added boost header

test/external/boost/graph/distributed/distributed_graph_utility.hpp

@@ -0,0 +1,154 @@
+// Copyright (C) 2005-2006 The Trustees of Indiana University.
+// Use, modification and distribution is subject to 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: Peter Gottschling
+//           Douglas Gregor
+//           Andrew Lumsdaine
+
+#include <boost/graph/iteration_macros.hpp>
+#include <boost/property_map/parallel/global_index_map.hpp>
+
+#ifndef BOOST_GRAPH_DISTRIBUTED_GRAPH_UTILITY_INCLUDE
+#define BOOST_GRAPH_DISTRIBUTED_GRAPH_UTILITY_INCLUDE
+
+#ifndef BOOST_GRAPH_USE_MPI
+#error "Parallel BGL files should not be included unless <boost/graph/use_mpi.hpp> has been included"
+#endif
+
+namespace boost { namespace graph {
+
+  template <class Property, class Graph>
+  void property_on_inedges(Property p, const Graph& g) 
+  {
+    BGL_FORALL_VERTICES_T(u, g, Graph)
+      BGL_FORALL_INEDGES_T(u, e, g, Graph)
+      request(p, e);
+    synchronize(p);
+  }
+  
+  // For reverse graphs
+  template <class Property, class Graph>
+  void property_on_outedges(Property p, const Graph& g) 
+  {
+    BGL_FORALL_VERTICES_T(u, g, Graph)
+      BGL_FORALL_OUTEDGES_T(u, e, g, Graph)
+        request(p, e);
+    synchronize(p);
+  }
+
+  template <class Property, class Graph>
+  void property_on_successors(Property p, const Graph& g) 
+  {
+    BGL_FORALL_VERTICES_T(u, g, Graph)
+      BGL_FORALL_OUTEDGES_T(u, e, g, Graph)
+        request(p, target(e, g));
+    synchronize(p);
+  }
+  
+  template <class Property, class Graph>
+  void property_on_predecessors(Property p, const Graph& g) 
+  {
+    BGL_FORALL_VERTICES_T(u, g, Graph)
+      BGL_FORALL_INEDGES_T(u, e, g, Graph)
+        request(p, source(e, g));
+    synchronize(p);
+  }
+  
+  // Like successors and predecessors but saves one synchronize (and a call)
+  template <class Property, class Graph>
+  void property_on_adjacents(Property p, const Graph& g) 
+  {
+    BGL_FORALL_VERTICES_T(u, g, Graph) {
+      BGL_FORALL_OUTEDGES_T(u, e, g, Graph)
+        request(p, target(e, g));
+      BGL_FORALL_INEDGES_T(u, e, g, Graph)
+        request(p, source(e, g));
+    }
+    synchronize(p);
+  }
+
+  template <class PropertyIn, class PropertyOut, class Graph>
+  void copy_vertex_property(PropertyIn p_in, PropertyOut p_out, Graph& g)
+  {
+    BGL_FORALL_VERTICES_T(u, g, Graph)
+      put(p_out, u, get(p_in, g));
+  }
+
+  template <class PropertyIn, class PropertyOut, class Graph>
+  void copy_edge_property(PropertyIn p_in, PropertyOut p_out, Graph& g)
+  {
+    BGL_FORALL_EDGES_T(e, g, Graph)
+      put(p_out, e, get(p_in, g));
+  }
+
+
+  namespace distributed {
+
+    // Define global_index<Graph>  global(graph);
+    // Then global(v) returns global index of v
+    template <typename Graph>
+    struct global_index
+    {
+      typedef typename property_map<Graph, vertex_index_t>::const_type
+      VertexIndexMap;
+      typedef typename property_map<Graph, vertex_global_t>::const_type
+      VertexGlobalMap;
+
+      explicit global_index(Graph const& g)
+        : global_index_map(process_group(g), num_vertices(g), get(vertex_index, g),
+                           get(vertex_global, g)) {}
+
+      int operator() (typename graph_traits<Graph>::vertex_descriptor v)
+      { return get(global_index_map, v); }
+    
+    protected:
+      boost::parallel::global_index_map<VertexIndexMap, VertexGlobalMap> 
+      global_index_map;
+    };
+
+    template<typename T>
+    struct additive_reducer {
+      BOOST_STATIC_CONSTANT(bool, non_default_resolver = true);
+      
+      template<typename K>
+      T operator()(const K&) const { return T(0); }
+      
+      template<typename K>
+      T operator()(const K&, const T& local, const T& remote) const { return local + remote; }
+    };
+
+    template <typename T>
+    struct choose_min_reducer {
+      BOOST_STATIC_CONSTANT(bool, non_default_resolver = true);
+      
+      template<typename K>
+      T operator()(const K&) const { return (std::numeric_limits<T>::max)(); }
+      
+      template<typename K>
+      T operator()(const K&, const T& x, const T& y) const 
+      { return x < y ? x : y; }
+    };
+
+    // To use a property map syntactically like a function
+    template <typename PropertyMap>
+    struct property_map_reader
+    {
+      explicit property_map_reader(PropertyMap pm) : pm(pm) {}
+
+      template <typename T>
+      typename PropertyMap::value_type
+      operator() (const T& v)
+      {
+        return get(pm, v);
+      }
+    private:
+      PropertyMap pm;
+    };
+
+  } // namespace distributed
+
+}} // namespace boost::graph
+
+#endif // BOOST_GRAPH_DISTRIBUTED_GRAPH_UTILITY_INCLUDE