Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r86381 - in trunk/boost: graph/detail graph/distributed graph/distributed/detail graph/parallel graph/parallel/detail property_map property_map/parallel property_map/parallel/detail property_map/parallel/impl
From: jewillco_at_[hidden]
Date: 2013-10-21 14:29:05

Author: jewillco
Date: 2013-10-21 14:29:04 EDT (Mon, 21 Oct 2013)
New Revision: 86381
URL: http://svn.boost.org/trac/boost/changeset/86381

Log:
Moved parts of PBGL used by parallel property maps over to property map directories and namespaces; this fixes circular dependencies between these two libraries (assuming boost/property_map/parallel is treated as a separate library)

Added:
   trunk/boost/property_map/parallel/basic_reduce.hpp
      - copied, changed from r86380, trunk/boost/graph/parallel/basic_reduce.hpp
   trunk/boost/property_map/parallel/detail/
   trunk/boost/property_map/parallel/detail/untracked_pair.hpp
      - copied, changed from r86380, trunk/boost/graph/parallel/detail/untracked_pair.hpp
   trunk/boost/property_map/parallel/parallel_property_maps.hpp
      - copied, changed from r86380, trunk/boost/property_map/property_map.hpp
   trunk/boost/property_map/parallel/process_group.hpp
      - copied, changed from r86380, trunk/boost/graph/parallel/process_group.hpp
   trunk/boost/property_map/parallel/simple_trigger.hpp
      - copied, changed from r86380, trunk/boost/graph/parallel/simple_trigger.hpp
   trunk/boost/property_map/parallel/unsafe_serialize.hpp
      - copied, changed from r86380, trunk/boost/graph/distributed/unsafe_serialize.hpp
Text files modified:
   trunk/boost/graph/detail/edge.hpp | 10
   trunk/boost/graph/distributed/adjacency_list.hpp | 26
   trunk/boost/graph/distributed/betweenness_centrality.hpp | 8
   trunk/boost/graph/distributed/boman_et_al_graph_coloring.hpp | 2
   trunk/boost/graph/distributed/delta_stepping_shortest_paths.hpp | 2
   trunk/boost/graph/distributed/detail/remote_update_set.hpp | 2
   trunk/boost/graph/distributed/mpi_process_group.hpp | 6
   trunk/boost/graph/distributed/named_graph.hpp | 4
   trunk/boost/graph/distributed/unsafe_serialize.hpp | 78 -----
   trunk/boost/graph/parallel/basic_reduce.hpp | 35 --
   trunk/boost/graph/parallel/detail/untracked_pair.hpp | 78 -----
   trunk/boost/graph/parallel/process_group.hpp | 94 ------
   trunk/boost/graph/parallel/simple_trigger.hpp | 99 ------
   trunk/boost/property_map/parallel/basic_reduce.hpp | 4
   trunk/boost/property_map/parallel/caching_property_map.hpp | 4
   trunk/boost/property_map/parallel/detail/untracked_pair.hpp | 4
   trunk/boost/property_map/parallel/distributed_property_map.hpp | 25 -
   trunk/boost/property_map/parallel/global_index_map.hpp | 4
   trunk/boost/property_map/parallel/impl/distributed_property_map.ipp | 10
   trunk/boost/property_map/parallel/local_property_map.hpp | 4
   trunk/boost/property_map/parallel/parallel_property_maps.hpp | 576 ---------------------------------------
   trunk/boost/property_map/parallel/process_group.hpp | 28 -
   trunk/boost/property_map/parallel/simple_trigger.hpp | 18
   trunk/boost/property_map/parallel/unsafe_serialize.hpp | 10
   trunk/boost/property_map/property_map.hpp | 200 -------------
   25 files changed, 85 insertions(+), 1246 deletions(-)

Modified: trunk/boost/graph/detail/edge.hpp
==============================================================================
--- trunk/boost/graph/detail/edge.hpp Mon Oct 21 08:26:30 2013 (r86380)
+++ trunk/boost/graph/detail/edge.hpp 2013-10-21 14:29:04 EDT (Mon, 21 Oct 2013) (r86381)
@@ -105,5 +105,15 @@
}
}

+// Boost's functional/hash
+namespace boost {
+ template<typename D, typename V>
+ struct hash<boost::detail::edge_desc_impl<D, V> >
+ {
+ std::size_t operator()(const boost::detail::edge_desc_impl<D, V> & x) const
+ { return hash_value(x.get_property()); }
+ };
+}
+

#endif // BOOST_GRAPH_DETAIL_DETAIL_EDGE_HPP

Modified: trunk/boost/graph/distributed/adjacency_list.hpp
==============================================================================
--- trunk/boost/graph/distributed/adjacency_list.hpp Mon Oct 21 08:26:30 2013 (r86380)
+++ trunk/boost/graph/distributed/adjacency_list.hpp 2013-10-21 14:29:04 EDT (Mon, 21 Oct 2013) (r86381)
@@ -1490,7 +1490,7 @@
     adjacency_list(const ProcessGroup& pg = ProcessGroup())
       : named_graph_mixin(pg, default_distribution_type(pg, 0)),
         m_local_graph(GraphProperty()),
- process_group_(pg, graph::parallel::attach_distributed_object())
+ process_group_(pg, boost::parallel::attach_distributed_object())
     {
       setup_triggers();
     }
@@ -1499,7 +1499,7 @@
                    const base_distribution_type& distribution)
       : named_graph_mixin(pg, distribution),
         m_local_graph(GraphProperty()),
- process_group_(pg, graph::parallel::attach_distributed_object())
+ process_group_(pg, boost::parallel::attach_distributed_object())
     {
       setup_triggers();
     }
@@ -1508,7 +1508,7 @@
                    const ProcessGroup& pg = ProcessGroup())
       : named_graph_mixin(pg, default_distribution_type(pg, 0)),
         m_local_graph(g),
- process_group_(pg, graph::parallel::attach_distributed_object())
+ process_group_(pg, boost::parallel::attach_distributed_object())
     {
       setup_triggers();
     }
@@ -1519,7 +1519,7 @@
                    const base_distribution_type& distribution)
       : named_graph_mixin(pg, distribution),
         m_local_graph(distribution.block_size(process_id(pg), n), p),
- process_group_(pg, graph::parallel::attach_distributed_object())
+ process_group_(pg, boost::parallel::attach_distributed_object())
     {
       setup_triggers();

@@ -1532,7 +1532,7 @@
                    const base_distribution_type& distribution)
       : named_graph_mixin(pg, distribution),
         m_local_graph(distribution.block_size(process_id(pg), n), GraphProperty()),
- process_group_(pg, graph::parallel::attach_distributed_object())
+ process_group_(pg, boost::parallel::attach_distributed_object())
     {
       setup_triggers();

@@ -1545,7 +1545,7 @@
                    const ProcessGroup& pg = ProcessGroup())
       : named_graph_mixin(pg, default_distribution_type(pg, n)),
         m_local_graph(this->distribution().block_size(process_id(pg), n), p),
- process_group_(pg, graph::parallel::attach_distributed_object())
+ process_group_(pg, boost::parallel::attach_distributed_object())
     {
       setup_triggers();

@@ -1558,7 +1558,7 @@
       : named_graph_mixin(pg, default_distribution_type(pg, n)),
         m_local_graph(this->distribution().block_size(process_id(pg), n),
                       GraphProperty()),
- process_group_(pg, graph::parallel::attach_distributed_object())
+ process_group_(pg, boost::parallel::attach_distributed_object())
     {
       setup_triggers();

@@ -1579,7 +1579,7 @@
                    const GraphProperty& p = GraphProperty())
       : named_graph_mixin(pg, default_distribution_type(pg, n)),
         m_local_graph(this->distribution().block_size(process_id(pg), n), p),
- process_group_(pg, graph::parallel::attach_distributed_object())
+ process_group_(pg, boost::parallel::attach_distributed_object())
     {
       setup_triggers();

@@ -1598,7 +1598,7 @@
                    const GraphProperty& p = GraphProperty())
       : named_graph_mixin(pg, default_distribution_type(pg, n)),
         m_local_graph(this->distribution().block_size(process_id(pg), n), p),
- process_group_(pg, graph::parallel::attach_distributed_object())
+ process_group_(pg, boost::parallel::attach_distributed_object())
     {
       setup_triggers();

@@ -1618,7 +1618,7 @@
                    const GraphProperty& p = GraphProperty())
       : named_graph_mixin(pg, distribution),
         m_local_graph(distribution.block_size(process_id(pg), n), p),
- process_group_(pg, graph::parallel::attach_distributed_object())
+ process_group_(pg, boost::parallel::attach_distributed_object())
     {
       setup_triggers();

@@ -1638,7 +1638,7 @@
                    const GraphProperty& p = GraphProperty())
       : named_graph_mixin(pg, distribution),
         m_local_graph(this->distribution().block_size(process_id(pg), n), p),
- process_group_(pg, graph::parallel::attach_distributed_object())
+ process_group_(pg, boost::parallel::attach_distributed_object())
     {
       setup_triggers();

@@ -2480,7 +2480,7 @@
       else {
         // Edge is remote, so notify the target's owner that an edge
         // has been added.
- if (self.process_group_.trigger_context() == graph::parallel::trc_out_of_band)
+ if (self.process_group_.trigger_context() == boost::parallel::trc_out_of_band)
           send_oob(self.process_group_, target.owner, msg_nonlocal_edge,
                    msg_nonlocal_edge_data(result.first.local, property));
         else
@@ -2519,7 +2519,7 @@
       else {
         // Edge is remote, so notify the target's owner that an edge
         // has been added.
- if (self.process_group_.trigger_context() == graph::parallel::trc_out_of_band)
+ if (self.process_group_.trigger_context() == boost::parallel::trc_out_of_band)
           send_oob(self.process_group_, target.owner, msg_nonlocal_edge,
                    msg_nonlocal_edge_data(result.first.local, property));
         else

Modified: trunk/boost/graph/distributed/betweenness_centrality.hpp
==============================================================================
--- trunk/boost/graph/distributed/betweenness_centrality.hpp Mon Oct 21 08:26:30 2013 (r86380)
+++ trunk/boost/graph/distributed/betweenness_centrality.hpp 2013-10-21 14:29:04 EDT (Mon, 21 Oct 2013) (r86381)
@@ -197,21 +197,21 @@
     // have not yet been received.
     void synchronize()
     {
- using boost::graph::parallel::synchronize;
+ using boost::parallel::synchronize;
       synchronize(pg);
     }

     // Setup triggers for msg_relax messages
     void setup_triggers()
     {
- using boost::graph::parallel::simple_trigger;
+ using boost::parallel::simple_trigger;
       simple_trigger(pg, msg_relax, this,
                      &betweenness_centrality_delta_stepping_impl::handle_msg_relax);
     }

     void handle_msg_relax(int /*source*/, int /*tag*/,
                           const std::pair<Vertex, typename MessageValue::type>& data,
- trigger_receive_context)
+ boost::parallel::trigger_receive_context)
     { relax(data.second.second, data.first, data.second.first); }

     const Graph& g;
@@ -281,7 +281,7 @@
       vertex_index(vertex_index),
#endif
       delta(delta),
- pg(boost::graph::parallel::process_group_adl(g), attach_distributed_object()),
+ pg(boost::graph::parallel::process_group_adl(g), boost::parallel::attach_distributed_object()),
       owner(get(vertex_owner, g)),
       local(get(vertex_local, g))

Modified: trunk/boost/graph/distributed/boman_et_al_graph_coloring.hpp
==============================================================================
--- trunk/boost/graph/distributed/boman_et_al_graph_coloring.hpp Mon Oct 21 08:26:30 2013 (r86380)
+++ trunk/boost/graph/distributed/boman_et_al_graph_coloring.hpp 2013-10-21 14:29:04 EDT (Mon, 21 Oct 2013) (r86381)
@@ -147,7 +147,7 @@
   typedef typename process_group_type::communication_category
     communication_category;
   static const bool asynchronous =
- is_convertible<communication_category, immediate_process_group_tag>::value;
+ is_convertible<communication_category, boost::parallel::immediate_process_group_tag>::value;
   process_group_type pg = process_group(g);

   // U_i <- V_i

Modified: trunk/boost/graph/distributed/delta_stepping_shortest_paths.hpp
==============================================================================
--- trunk/boost/graph/distributed/delta_stepping_shortest_paths.hpp Mon Oct 21 08:26:30 2013 (r86380)
+++ trunk/boost/graph/distributed/delta_stepping_shortest_paths.hpp 2013-10-21 14:29:04 EDT (Mon, 21 Oct 2013) (r86381)
@@ -433,7 +433,7 @@
delta_stepping_impl<Graph, PredecessorMap, DistanceMap, EdgeWeightMap>::
synchronize()
{
- using boost::graph::parallel::synchronize;
+ using boost::parallel::synchronize;

// Synchronize at the process group level.
synchronize(pg);

Modified: trunk/boost/graph/distributed/detail/remote_update_set.hpp
==============================================================================
--- trunk/boost/graph/distributed/detail/remote_update_set.hpp Mon Oct 21 08:26:30 2013 (r86380)
+++ trunk/boost/graph/distributed/detail/remote_update_set.hpp 2013-10-21 14:29:04 EDT (Mon, 21 Oct 2013) (r86381)
@@ -39,7 +39,7 @@
     (bool,
      queued = (is_convertible<
                  typename ProcessGroup::communication_category,
- parallel::bsp_process_group_tag>::value));
+ boost::parallel::bsp_process_group_tag>::value));

  public:
   typedef typename mpl::if_c<queued,

Modified: trunk/boost/graph/distributed/mpi_process_group.hpp
==============================================================================
--- trunk/boost/graph/distributed/mpi_process_group.hpp Mon Oct 21 08:26:30 2013 (r86380)
+++ trunk/boost/graph/distributed/mpi_process_group.hpp 2013-10-21 14:29:04 EDT (Mon, 21 Oct 2013) (r86381)
@@ -28,13 +28,13 @@
#include <boost/function/function2.hpp>
#include <boost/function/function0.hpp>
#include <boost/mpi.hpp>
-#include <boost/graph/parallel/process_group.hpp>
+#include <boost/property_map/parallel/process_group.hpp>
#include <boost/utility/enable_if.hpp>

namespace boost { namespace graph { namespace distributed {

// Process group tags
-struct mpi_process_group_tag : virtual parallel::linear_process_group_tag { };
+struct mpi_process_group_tag : virtual boost::parallel::linear_process_group_tag { };

class mpi_process_group
{
@@ -75,7 +75,7 @@

   /// Classification of the capabilities of this process group
   struct communication_category
- : virtual parallel::bsp_process_group_tag,
+ : virtual boost::parallel::bsp_process_group_tag,
       virtual mpi_process_group_tag { };

   // TBD: We can eliminate the "source" field and possibly the

Modified: trunk/boost/graph/distributed/named_graph.hpp
==============================================================================
--- trunk/boost/graph/distributed/named_graph.hpp Mon Oct 21 08:26:30 2013 (r86380)
+++ trunk/boost/graph/distributed/named_graph.hpp 2013-10-21 14:29:04 EDT (Mon, 21 Oct 2013) (r86381)
@@ -804,7 +804,7 @@
/// Construct the named_graph with a particular process group
template<BGL_NAMED_GRAPH_PARAMS>
BGL_NAMED_GRAPH::named_graph(const process_group_type& pg)
- : process_group_(pg, parallel::attach_distributed_object()),
+ : process_group_(pg, boost::parallel::attach_distributed_object()),
     distribution_(pg)
{
   setup_triggers();
@@ -815,7 +815,7 @@
template<BGL_NAMED_GRAPH_PARAMS>
BGL_NAMED_GRAPH::named_graph(const process_group_type& pg,
                              const base_distribution_type& distribution)
- : process_group_(pg, parallel::attach_distributed_object()),
+ : process_group_(pg, boost::parallel::attach_distributed_object()),
     distribution_(pg, distribution)
{
   setup_triggers();

Modified: trunk/boost/graph/distributed/unsafe_serialize.hpp
==============================================================================
--- trunk/boost/graph/distributed/unsafe_serialize.hpp Mon Oct 21 08:26:30 2013 (r86380)
+++ trunk/boost/graph/distributed/unsafe_serialize.hpp 2013-10-21 14:29:04 EDT (Mon, 21 Oct 2013) (r86381)
@@ -7,79 +7,5 @@
// Authors: Douglas Gregor
// Andrew Lumsdaine

-// This file contains the "unsafe_serialize" routine, which transforms
-// types they may not be serializable (such as void*) into
-// serializable equivalents.
-#ifndef PBGL_UNSAFE_SERIALIZE_HPP
-#define PBGL_UNSAFE_SERIALIZE_HPP
-
-#ifndef BOOST_GRAPH_USE_MPI
-#error "Parallel BGL files should not be included unless <boost/graph/use_mpi.hpp> has been included"
-#endif
-
-#include <boost/mpi/datatype.hpp>
-#include <boost/serialization/is_bitwise_serializable.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/cstdint.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/type_traits.hpp>
-#include <utility>
-
-BOOST_IS_BITWISE_SERIALIZABLE(void*)
-namespace boost { namespace mpi {
- template<> struct is_mpi_datatype<void*> : mpl::true_ { };
-} } // end namespace boost::mpi
-
-namespace boost {
- typedef mpl::if_c<(sizeof(int) == sizeof(void*)),
- int,
- mpl::if_c<(sizeof(long) == sizeof(void*)),
- long,
- mpl::if_c<(sizeof(void*) <= sizeof(boost::intmax_t)),
- boost::intmax_t,
- void>::type
- >::type
- >::type ptr_serialize_type;
-
- BOOST_STATIC_ASSERT ((!boost::is_void<ptr_serialize_type>::value));
-
- template<typename T> inline T& unsafe_serialize(T& x) { return x; }
-
- inline ptr_serialize_type& unsafe_serialize(void*& x)
- { return reinterpret_cast<ptr_serialize_type&>(x); }
-
- // Force Boost.MPI to serialize a void* like a ptr_serialize_type
- namespace mpi {
- template<> inline MPI_Datatype get_mpi_datatype<void*>(void* const& x)
- {
- return get_mpi_datatype<ptr_serialize_type>();
- }
- }
-
- template<typename T, typename U>
- struct unsafe_pair
- {
- unsafe_pair() { }
- unsafe_pair(const T& t, const U& u) : first(t), second(u) { }
- unsafe_pair(const std::pair<T, U>& p) : first(p.first), second(p.second) { }
- T first;
- U second;
-
- template<typename Archiver>
- void serialize(Archiver& ar, const unsigned /*version*/)
- {
- ar & unsafe_serialize(first) & unsafe_serialize(second);
- }
- };
-
- template<typename T, typename U>
- bool operator<(unsafe_pair<T,U> const& x, unsafe_pair<T,U> const& y)
- {
- return std::make_pair(x.first, x.second) <
- std::make_pair(y.first, y.second);
- }
-
-} // end namespace boost
-
-#endif // PBGL_UNSAFE_SERIALIZE_HPP
+// File moved
+#include <boost/property_map/parallel/unsafe_serialize.hpp>

Modified: trunk/boost/graph/parallel/basic_reduce.hpp
==============================================================================
--- trunk/boost/graph/parallel/basic_reduce.hpp Mon Oct 21 08:26:30 2013 (r86380)
+++ trunk/boost/graph/parallel/basic_reduce.hpp 2013-10-21 14:29:04 EDT (Mon, 21 Oct 2013) (r86381)
@@ -7,36 +7,5 @@
// Authors: Douglas Gregor
// Andrew Lumsdaine

-#ifndef BOOST_PARALLEL_BASIC_REDUCE_HPP
-#define BOOST_PARALLEL_BASIC_REDUCE_HPP
-
-#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 parallel {
-
-/** Reduction operation used to reconcile differences between local
- * and remote values for a particular key in a property map. The
- * type @c T is typically the @c value_type of the property
- * map. This basic reduction returns a default-constructed @c T as
- * the default value and always resolves to the remote value.
- */
-template<typename T>
-struct basic_reduce
-{
- BOOST_STATIC_CONSTANT(bool, non_default_resolver = false);
-
- /// Returns a default-constructed T object
- template<typename Key>
- T operator()(const Key&) const { return T(); }
-
- /// Returns the remote value
- template<typename Key>
- const T& operator()(const Key&, const T&, const T& remote) const
- { return remote; }
-};
-
-} } // end namespace boost::parallel
-
-#endif // BOOST_PARALLEL_BASIC_REDUCE_HPP
+// File moved
+#include <boost/property_map/parallel/basic_reduce.hpp>

Modified: trunk/boost/graph/parallel/detail/untracked_pair.hpp
==============================================================================
--- trunk/boost/graph/parallel/detail/untracked_pair.hpp Mon Oct 21 08:26:30 2013 (r86380)
+++ trunk/boost/graph/parallel/detail/untracked_pair.hpp 2013-10-21 14:29:04 EDT (Mon, 21 Oct 2013) (r86381)
@@ -6,80 +6,6 @@
// This file contains helper data structures for use in transmitting
// properties. The basic idea is to optimize away any storage for the
// properties when no properties are specified.
-#ifndef BOOST_PARALLEL_DETAIL_UNTRACKED_PAIR_HPP
-#define BOOST_PARALLEL_DETAIL_UNTRACKED_PAIR_HPP

-#ifndef BOOST_GRAPH_USE_MPI
-#error "Parallel BGL files should not be included unless <boost/graph/use_mpi.hpp> has been included"
-#endif
-
-#include <boost/mpi/datatype.hpp>
-#include <utility> // for std::pair
-#include <boost/serialization/utility.hpp>
-
-namespace boost { namespace parallel { namespace detail {
-
-/**
- * This structure is like std::pair, with the only difference
- * that tracking in the serialization library is turned off.
- */
-
-template<typename T, typename U>
-struct untracked_pair : public std::pair<T,U>
-{
- untracked_pair() {}
-
- untracked_pair(const T& t, const U& u)
- : std::pair<T,U>(t,u) {}
-
- template<class T1, class U1>
- untracked_pair(std::pair<T1,U1> const& p)
- : std::pair<T,U>(p) {}
-};
-
-template<typename T, typename U>
-inline untracked_pair<T, U>
-make_untracked_pair(const T& t, const U& u)
-{
- return untracked_pair<T,U>(t,u);
-}
-
-} } } // end namespace boost::parallel::detail
-
-namespace boost { namespace mpi {
-
-template<typename T, typename U>
-struct is_mpi_datatype<boost::parallel::detail::untracked_pair<T, U> >
- : is_mpi_datatype<std::pair<T,U> > {};
-
-} } // end namespace boost::mpi
-
-namespace boost { namespace serialization {
-
-// pair
-template<class Archive, class F, class S>
-inline void serialize(
- Archive & ar,
- boost::parallel::detail::untracked_pair<F, S> & p,
- const unsigned int /* file_version */
-){
- ar & boost::serialization::make_nvp("first", p.first);
- ar & boost::serialization::make_nvp("second", p.second);
-}
-
-template<typename T, typename U>
-struct is_bitwise_serializable<
- boost::parallel::detail::untracked_pair<T, U> >
- : is_bitwise_serializable<std::pair<T, U> > {};
-
-template<typename T, typename U>
-struct implementation_level<boost::parallel::detail::untracked_pair<T, U> >
- : mpl::int_<object_serializable> {} ;
-
-template<typename T, typename U>
-struct tracking_level<boost::parallel::detail::untracked_pair<T, U> >
- : mpl::int_<track_never> {} ;
-
-} } // end namespace boost::serialization
-
-#endif // BOOST_PARALLEL_DETAIL_UNTRACKED_PAIR_HPP
+// File moved
+#include <boost/property_map/parallel/detail/untracked_pair.hpp>

Modified: trunk/boost/graph/parallel/process_group.hpp
==============================================================================
--- trunk/boost/graph/parallel/process_group.hpp Mon Oct 21 08:26:30 2013 (r86380)
+++ trunk/boost/graph/parallel/process_group.hpp 2013-10-21 14:29:04 EDT (Mon, 21 Oct 2013) (r86381)
@@ -6,96 +6,6 @@

// Authors: Douglas Gregor
// Andrew Lumsdaine
-#ifndef BOOST_GRAPH_PARALLEL_PROCESS_GROUP_HPP
-#define BOOST_GRAPH_PARALLEL_PROCESS_GROUP_HPP

-#ifndef BOOST_GRAPH_USE_MPI
-#error "Parallel BGL files should not be included unless <boost/graph/use_mpi.hpp> has been included"
-#endif
-
-#include <cstdlib>
-#include <utility>
-
-namespace boost { namespace graph { namespace parallel {
-
-/**
- * A special type used as a flag to a process group constructor that
- * indicates that the copy of a process group will represent a new
- * distributed data structure.
- */
-struct attach_distributed_object { };
-
-/**
- * Describes the context in which a trigger is being invoked to
- * receive a message.
- */
-enum trigger_receive_context {
- /// No trigger is active at this time.
- trc_none,
- /// The trigger is being invoked during synchronization, at the end
- /// of a superstep.
- trc_in_synchronization,
- /// The trigger is being invoked as an "early" receive of a message
- /// that was sent through the normal "send" operations to be
- /// received by the end of the superstep, but the process group sent
- /// the message earlier to clear its buffers.
- trc_early_receive,
- /// The trigger is being invoked for an out-of-band message, which
- /// must be handled immediately.
- trc_out_of_band,
- /// The trigger is being invoked for an out-of-band message, which
- /// must be handled immediately and has alredy been received by
- /// an MPI_IRecv call.
- trc_irecv_out_of_band
-};
-
-// Process group tags
-struct process_group_tag {};
-struct linear_process_group_tag : virtual process_group_tag {};
-struct messaging_process_group_tag : virtual process_group_tag {};
-struct immediate_process_group_tag : virtual messaging_process_group_tag {};
-struct bsp_process_group_tag : virtual messaging_process_group_tag {};
-struct batch_process_group_tag : virtual messaging_process_group_tag {};
-struct locking_process_group_tag : virtual process_group_tag {};
-struct spawning_process_group_tag : virtual process_group_tag {};
-
-struct process_group_archetype
-{
- typedef int process_id_type;
-};
-
-void wait(process_group_archetype&);
-void synchronize(process_group_archetype&);
-int process_id(const process_group_archetype&);
-int num_processes(const process_group_archetype&);
-
-template<typename T> void send(process_group_archetype&, int, int, const T&);
-
-template<typename T>
-process_group_archetype::process_id_type
-receive(const process_group_archetype& pg,
- process_group_archetype::process_id_type source, int tag, T& value);
-
-template<typename T>
-std::pair<process_group_archetype::process_id_type, std::size_t>
-receive(const process_group_archetype& pg, int tag, T values[], std::size_t n);
-
-template<typename T>
-std::pair<process_group_archetype::process_id_type, std::size_t>
-receive(const process_group_archetype& pg,
- process_group_archetype::process_id_type source, int tag, T values[],
- std::size_t n);
-
-} } } // end namespace boost::graph::parallel
-
-namespace boost { namespace graph { namespace distributed {
- using parallel::trigger_receive_context;
- using parallel::trc_early_receive;
- using parallel::trc_out_of_band;
- using parallel::trc_irecv_out_of_band;
- using parallel::trc_in_synchronization;
- using parallel::trc_none;
- using parallel::attach_distributed_object;
-} } } // end namespace boost::graph::distributed
-
-#endif // BOOST_GRAPH_PARALLEL_PROCESS_GROUP_HPP
+// File moved
+#include <boost/property_map/parallel/process_group.hpp>

Modified: trunk/boost/graph/parallel/simple_trigger.hpp
==============================================================================
--- trunk/boost/graph/parallel/simple_trigger.hpp Mon Oct 21 08:26:30 2013 (r86380)
+++ trunk/boost/graph/parallel/simple_trigger.hpp 2013-10-21 14:29:04 EDT (Mon, 21 Oct 2013) (r86381)
@@ -9,100 +9,5 @@
// the handler associated with a trigger is a member function bound to
// a particular pointer.

-#ifndef BOOST_GRAPH_PARALLEL_SIMPLE_TRIGGER_HPP
-#define BOOST_GRAPH_PARALLEL_SIMPLE_TRIGGER_HPP
-
-#ifndef BOOST_GRAPH_USE_MPI
-#error "Parallel BGL files should not be included unless <boost/graph/use_mpi.hpp> has been included"
-#endif
-
-#include <boost/graph/parallel/process_group.hpp>
-
-namespace boost { namespace graph { namespace parallel {
-
-namespace detail {
-
-/**
- * INTERNAL ONLY
- *
- * The actual function object that bridges from the normal trigger
- * interface to the simplified interface. This is the equivalent of
- * bind(pmf, self, _1, _2, _3, _4), but without the compile-time
- * overhead of bind.
- */
-template<typename Class, typename T, typename Result>
-class simple_trigger_t
-{
-public:
- simple_trigger_t(Class* self,
- Result (Class::*pmf)(int, int, const T&,
- trigger_receive_context))
- : self(self), pmf(pmf) { }
-
- Result
- operator()(int source, int tag, const T& data,
- trigger_receive_context context) const
- {
- return (self->*pmf)(source, tag, data, context);
- }
-
-private:
- Class* self;
- Result (Class::*pmf)(int, int, const T&, trigger_receive_context);
-};
-
-} // end namespace detail
-
-/**
- * Simplified trigger interface that reduces the amount of code
- * required to connect a process group trigger to a handler that is
- * just a bound member function.
- *
- * INTERNAL ONLY
- */
-template<typename ProcessGroup, typename Class, typename T>
-inline void
-simple_trigger(ProcessGroup& pg, int tag, Class* self,
- void (Class::*pmf)(int source, int tag, const T& data,
- trigger_receive_context context), int)
-{
- pg.template trigger<T>(tag,
- detail::simple_trigger_t<Class, T, void>(self, pmf));
-}
-
-/**
- * Simplified trigger interface that reduces the amount of code
- * required to connect a process group trigger with a reply to a
- * handler that is just a bound member function.
- *
- * INTERNAL ONLY
- */
-template<typename ProcessGroup, typename Class, typename T, typename Result>
-inline void
-simple_trigger(ProcessGroup& pg, int tag, Class* self,
- Result (Class::*pmf)(int source, int tag, const T& data,
- trigger_receive_context context), long)
-{
- pg.template trigger_with_reply<T>
- (tag, detail::simple_trigger_t<Class, T, Result>(self, pmf));
-}
-
-/**
- * Simplified trigger interface that reduces the amount of code
- * required to connect a process group trigger to a handler that is
- * just a bound member function.
- */
-template<typename ProcessGroup, typename Class, typename T, typename Result>
-inline void
-simple_trigger(ProcessGroup& pg, int tag, Class* self,
- Result (Class::*pmf)(int source, int tag, const T& data,
- trigger_receive_context context))
-{
- // We pass 0 (an int) to help VC++ disambiguate calls to simple_trigger
- // with Result=void.
- simple_trigger(pg, tag, self, pmf, 0);
-}
-
-} } } // end namespace boost::graph::parallel
-
-#endif // BOOST_GRAPH_PARALLEL_SIMPLE_TRIGGER_HPP
+// File moved
+#include <boost/property_map/parallel/simple_trigger.hpp>

Copied and modified: trunk/boost/property_map/parallel/basic_reduce.hpp (from r86380, trunk/boost/graph/parallel/basic_reduce.hpp)
==============================================================================
--- trunk/boost/graph/parallel/basic_reduce.hpp Mon Oct 21 08:26:30 2013 (r86380, copy source)
+++ trunk/boost/property_map/parallel/basic_reduce.hpp 2013-10-21 14:29:04 EDT (Mon, 21 Oct 2013) (r86381)
@@ -10,10 +10,6 @@
#ifndef BOOST_PARALLEL_BASIC_REDUCE_HPP
#define BOOST_PARALLEL_BASIC_REDUCE_HPP

-#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 parallel {

/** Reduction operation used to reconcile differences between local

Modified: trunk/boost/property_map/parallel/caching_property_map.hpp
==============================================================================
--- trunk/boost/property_map/parallel/caching_property_map.hpp Mon Oct 21 08:26:30 2013 (r86380)
+++ trunk/boost/property_map/parallel/caching_property_map.hpp 2013-10-21 14:29:04 EDT (Mon, 21 Oct 2013) (r86381)
@@ -9,10 +9,6 @@
#ifndef BOOST_PARALLEL_CACHING_PROPERTY_MAP_HPP
#define BOOST_PARALLEL_CACHING_PROPERTY_MAP_HPP

-#ifndef BOOST_GRAPH_USE_MPI
-#error "Parallel BGL files should not be included unless <boost/graph/use_mpi.hpp> has been included"
-#endif
-
#include <boost/property_map/property_map.hpp>

namespace boost {

Copied and modified: trunk/boost/property_map/parallel/detail/untracked_pair.hpp (from r86380, trunk/boost/graph/parallel/detail/untracked_pair.hpp)
==============================================================================
--- trunk/boost/graph/parallel/detail/untracked_pair.hpp Mon Oct 21 08:26:30 2013 (r86380, copy source)
+++ trunk/boost/property_map/parallel/detail/untracked_pair.hpp 2013-10-21 14:29:04 EDT (Mon, 21 Oct 2013) (r86381)
@@ -9,10 +9,6 @@
#ifndef BOOST_PARALLEL_DETAIL_UNTRACKED_PAIR_HPP
#define BOOST_PARALLEL_DETAIL_UNTRACKED_PAIR_HPP

-#ifndef BOOST_GRAPH_USE_MPI
-#error "Parallel BGL files should not be included unless <boost/graph/use_mpi.hpp> has been included"
-#endif
-
#include <boost/mpi/datatype.hpp>
#include <utility> // for std::pair
#include <boost/serialization/utility.hpp>

Modified: trunk/boost/property_map/parallel/distributed_property_map.hpp
==============================================================================
--- trunk/boost/property_map/parallel/distributed_property_map.hpp Mon Oct 21 08:26:30 2013 (r86380)
+++ trunk/boost/property_map/parallel/distributed_property_map.hpp 2013-10-21 14:29:04 EDT (Mon, 21 Oct 2013) (r86381)
@@ -17,27 +17,22 @@
#ifndef BOOST_PARALLEL_DISTRIBUTED_PROPERTY_MAP_HPP
#define BOOST_PARALLEL_DISTRIBUTED_PROPERTY_MAP_HPP

-#ifndef BOOST_GRAPH_USE_MPI
-#error "Parallel BGL files should not be included unless <boost/graph/use_mpi.hpp> has been included"
-#endif
-
#include <boost/assert.hpp>
#include <boost/type_traits/is_base_and_derived.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>
#include <boost/optional.hpp>
-#include <boost/graph/parallel/process_group.hpp>
-#include <boost/graph/detail/edge.hpp>
+#include <boost/property_map/parallel/process_group.hpp>
#include <boost/function/function1.hpp>
#include <vector>
#include <set>
-#include <boost/graph/parallel/basic_reduce.hpp>
-#include <boost/graph/parallel/detail/untracked_pair.hpp>
+#include <boost/property_map/parallel/basic_reduce.hpp>
+#include <boost/property_map/parallel/detail/untracked_pair.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/property_map/parallel/local_property_map.hpp>
#include <map>
#include <boost/version.hpp>
-#include <boost/graph/distributed/unsafe_serialize.hpp>
+#include <boost/property_map/parallel/unsafe_serialize.hpp>
#include <boost/multi_index_container.hpp>
#include <boost/multi_index/hashed_index.hpp>
#include <boost/multi_index/member.hpp>
@@ -48,8 +43,6 @@

namespace boost { namespace parallel {

-using boost::graph::parallel::trigger_receive_context;
-
namespace detail {
/**************************************************************************
* Metafunction that degrades an Lvalue Property Map category tag to
@@ -693,16 +686,6 @@

} } // end namespace boost::parallel

-// Boost's functional/hash
-namespace boost {
- template<typename D, typename V>
- struct hash<boost::detail::edge_desc_impl<D, V> >
- {
- std::size_t operator()(const boost::detail::edge_desc_impl<D, V> & x) const
- { return hash_value(x.get_property()); }
- };
-}
-
#include <boost/property_map/parallel/impl/distributed_property_map.ipp>

#undef PBGL_DISTRIB_PMAP

Modified: trunk/boost/property_map/parallel/global_index_map.hpp
==============================================================================
--- trunk/boost/property_map/parallel/global_index_map.hpp Mon Oct 21 08:26:30 2013 (r86380)
+++ trunk/boost/property_map/parallel/global_index_map.hpp 2013-10-21 14:29:04 EDT (Mon, 21 Oct 2013) (r86381)
@@ -9,10 +9,6 @@
#ifndef BOOST_PARALLEL_GLOBAL_INDEX_MAP_HPP
#define BOOST_PARALLEL_GLOBAL_INDEX_MAP_HPP

-#ifndef BOOST_GRAPH_USE_MPI
-#error "Parallel BGL files should not be included unless <boost/graph/use_mpi.hpp> has been included"
-#endif
-
#include <boost/property_map/property_map.hpp>
#include <vector>
#include <boost/shared_ptr.hpp>

Modified: trunk/boost/property_map/parallel/impl/distributed_property_map.ipp
==============================================================================
--- trunk/boost/property_map/parallel/impl/distributed_property_map.ipp Mon Oct 21 08:26:30 2013 (r86380)
+++ trunk/boost/property_map/parallel/impl/distributed_property_map.ipp 2013-10-21 14:29:04 EDT (Mon, 21 Oct 2013) (r86381)
@@ -9,14 +9,10 @@
// Andrew Lumsdaine
#include <boost/assert.hpp>
#include <boost/property_map/parallel/distributed_property_map.hpp>
-#include <boost/graph/parallel/detail/untracked_pair.hpp>
+#include <boost/property_map/parallel/detail/untracked_pair.hpp>
#include <boost/type_traits/is_base_and_derived.hpp>
#include <boost/bind.hpp>
-#include <boost/graph/parallel/simple_trigger.hpp>
-
-#ifndef BOOST_GRAPH_USE_MPI
-#error "Parallel BGL files should not be included unless <boost/graph/use_mpi.hpp> has been included"
-#endif
+#include <boost/property_map/parallel/simple_trigger.hpp>

namespace boost { namespace parallel {

@@ -243,7 +239,7 @@
PBGL_DISTRIB_PMAP::handle_message<Reduce>::
setup_triggers(process_group_type& pg)
{
- using boost::graph::parallel::simple_trigger;
+ using boost::parallel::simple_trigger;

simple_trigger(pg, property_map_put, this, &handle_message::handle_put);
simple_trigger(pg, property_map_get, this, &handle_message::handle_get);

Modified: trunk/boost/property_map/parallel/local_property_map.hpp
==============================================================================
--- trunk/boost/property_map/parallel/local_property_map.hpp Mon Oct 21 08:26:30 2013 (r86380)
+++ trunk/boost/property_map/parallel/local_property_map.hpp 2013-10-21 14:29:04 EDT (Mon, 21 Oct 2013) (r86381)
@@ -16,10 +16,6 @@
#ifndef BOOST_PARALLEL_LOCAL_PROPERTY_MAP_HPP
#define BOOST_PARALLEL_LOCAL_PROPERTY_MAP_HPP

-#ifndef BOOST_GRAPH_USE_MPI
-#error "Parallel BGL files should not be included unless <boost/graph/use_mpi.hpp> has been included"
-#endif
-
#include <boost/assert.hpp>

namespace boost {

Copied and modified: trunk/boost/property_map/parallel/parallel_property_maps.hpp (from r86380, trunk/boost/property_map/property_map.hpp)
==============================================================================
--- trunk/boost/property_map/property_map.hpp Mon Oct 21 08:26:30 2013 (r86380, copy source)
+++ trunk/boost/property_map/parallel/parallel_property_maps.hpp 2013-10-21 14:29:04 EDT (Mon, 21 Oct 2013) (r86381)
@@ -8,8 +8,12 @@

// See http://www.boost.org/libs/property_map for documentation.

-#ifndef BOOST_PROPERTY_MAP_HPP
-#define BOOST_PROPERTY_MAP_HPP
+#ifndef BOOST_PROPERTY_MAP_PARALLEL_PROPERTY_MAPS_HPP
+#define BOOST_PROPERTY_MAP_PARALLEL_PROPERTY_MAPS_HPP
+
+// Parallel property maps moved over from <boost/property_map/property_map.hpp>
+// as part of refactoring out all parallel code from sequential property map
+// library.

#include <boost/assert.hpp>
#include <boost/config.hpp>
@@ -23,571 +27,8 @@
#include <boost/mpl/and.hpp>
#include <boost/mpl/has_xxx.hpp>
#include <boost/type_traits/is_same.hpp>
+#include <boost/property_map/property_map.hpp>

-namespace boost {
-
- //=========================================================================
- // property_traits class
-
- BOOST_MPL_HAS_XXX_TRAIT_DEF(key_type)
- BOOST_MPL_HAS_XXX_TRAIT_DEF(value_type)
- BOOST_MPL_HAS_XXX_TRAIT_DEF(reference)
- BOOST_MPL_HAS_XXX_TRAIT_DEF(category)
-
- template<class PA>
- struct is_property_map :
- boost::mpl::and_<
- has_key_type<PA>,
- has_value_type<PA>,
- has_reference<PA>,
- has_category<PA>
- >
- {};
-
- template <typename PA>
- struct default_property_traits {
- typedef typename PA::key_type key_type;
- typedef typename PA::value_type value_type;
- typedef typename PA::reference reference;
- typedef typename PA::category category;
- };
-
- struct null_property_traits {};
-
- template <typename PA>
- struct property_traits :
- boost::mpl::if_<is_property_map<PA>,
- default_property_traits<PA>,
- null_property_traits>::type
- {};
-
-#if 0
- template <typename PA>
- struct property_traits {
- typedef typename PA::key_type key_type;
- typedef typename PA::value_type value_type;
- typedef typename PA::reference reference;
- typedef typename PA::category category;
- };
-#endif
-
- //=========================================================================
- // property_traits category tags
-
- namespace detail {
- enum ePropertyMapID { READABLE_PA, WRITABLE_PA,
- READ_WRITE_PA, LVALUE_PA, OP_BRACKET_PA,
- RAND_ACCESS_ITER_PA, LAST_PA };
- }
- struct readable_property_map_tag { enum { id = detail::READABLE_PA }; };
- struct writable_property_map_tag { enum { id = detail::WRITABLE_PA }; };
- struct read_write_property_map_tag :
- public readable_property_map_tag,
- public writable_property_map_tag
- { enum { id = detail::READ_WRITE_PA }; };
-
- struct lvalue_property_map_tag : public read_write_property_map_tag
- { enum { id = detail::LVALUE_PA }; };
-
- //=========================================================================
- // property_traits specialization for pointers
-
- template <class T>
- struct property_traits<T*> {
- // BOOST_STATIC_ASSERT(boost::is_same<T, T*>::value && !"Using pointers as property maps is deprecated");
- typedef T value_type;
- typedef value_type& reference;
- typedef std::ptrdiff_t key_type;
- typedef lvalue_property_map_tag category;
- };
- template <class T>
- struct property_traits<const T*> {
- // BOOST_STATIC_ASSERT(boost::is_same<T, T*>::value && !"Using pointers as property maps is deprecated");
- typedef T value_type;
- typedef const value_type& reference;
- typedef std::ptrdiff_t key_type;
- typedef lvalue_property_map_tag category;
- };
-
-#if !defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
- // MSVC doesn't have Koenig lookup, so the user has to
- // do boost::get() anyways, and the using clause
- // doesn't really work for MSVC.
-} // namespace boost
-#endif
-
- // These need to go in global namespace because Koenig
- // lookup does not apply to T*.
-
- // V must be convertible to T
- template <class T, class V>
- inline void put(T* pa, std::ptrdiff_t k, const V& val) { pa[k] = val; }
-
- template <class T>
- inline const T& get(const T* pa, std::ptrdiff_t k) { return pa[k]; }
-
-#if !defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
-namespace boost {
- using ::put;
- using ::get;
-#endif
-
- //=========================================================================
- // concept checks for property maps
-
- template <class PMap, class Key>
- struct ReadablePropertyMapConcept
- {
- typedef typename property_traits<PMap>::key_type key_type;
- typedef typename property_traits<PMap>::reference reference;
- typedef typename property_traits<PMap>::category Category;
- typedef boost::readable_property_map_tag ReadableTag;
- void constraints() {
- function_requires< ConvertibleConcept<Category, ReadableTag> >();
-
- val = get(pmap, k);
- }
- PMap pmap;
- Key k;
- typename property_traits<PMap>::value_type val;
- };
- template <typename KeyArchetype, typename ValueArchetype>
- struct readable_property_map_archetype {
- typedef KeyArchetype key_type;
- typedef ValueArchetype value_type;
- typedef convertible_to_archetype<ValueArchetype> reference;
- typedef readable_property_map_tag category;
- };
- template <typename K, typename V>
- const typename readable_property_map_archetype<K,V>::reference&
- get(const readable_property_map_archetype<K,V>&,
- const typename readable_property_map_archetype<K,V>::key_type&)
- {
- typedef typename readable_property_map_archetype<K,V>::reference R;
- return static_object<R>::get();
- }
-
-
- template <class PMap, class Key>
- struct WritablePropertyMapConcept
- {
- typedef typename property_traits<PMap>::key_type key_type;
- typedef typename property_traits<PMap>::category Category;
- typedef boost::writable_property_map_tag WritableTag;
- void constraints() {
- function_requires< ConvertibleConcept<Category, WritableTag> >();
- put(pmap, k, val);
- }
- PMap pmap;
- Key k;
- typename property_traits<PMap>::value_type val;
- };
- template <typename KeyArchetype, typename ValueArchetype>
- struct writable_property_map_archetype {
- typedef KeyArchetype key_type;
- typedef ValueArchetype value_type;
- typedef void reference;
- typedef writable_property_map_tag category;
- };
- template <typename K, typename V>
- void put(const writable_property_map_archetype<K,V>&,
- const typename writable_property_map_archetype<K,V>::key_type&,
- const typename writable_property_map_archetype<K,V>::value_type&) { }
-
-
- template <class PMap, class Key>
- struct ReadWritePropertyMapConcept
- {
- typedef typename property_traits<PMap>::category Category;
- typedef boost::read_write_property_map_tag ReadWriteTag;
- void constraints() {
- function_requires< ReadablePropertyMapConcept<PMap, Key> >();
- function_requires< WritablePropertyMapConcept<PMap, Key> >();
- function_requires< ConvertibleConcept<Category, ReadWriteTag> >();
- }
- };
- template <typename KeyArchetype, typename ValueArchetype>
- struct read_write_property_map_archetype
- : public readable_property_map_archetype<KeyArchetype, ValueArchetype>,
- public writable_property_map_archetype<KeyArchetype, ValueArchetype>
- {
- typedef KeyArchetype key_type;
- typedef ValueArchetype value_type;
- typedef convertible_to_archetype<ValueArchetype> reference;
- typedef read_write_property_map_tag category;
- };
-
-
- template <class PMap, class Key>
- struct LvaluePropertyMapConcept
- {
- typedef typename property_traits<PMap>::category Category;
- typedef boost::lvalue_property_map_tag LvalueTag;
- typedef typename property_traits<PMap>::reference reference;
-
- void constraints() {
- function_requires< ReadablePropertyMapConcept<PMap, Key> >();
- function_requires< ConvertibleConcept<Category, LvalueTag> >();
-
- typedef typename property_traits<PMap>::value_type value_type;
- BOOST_MPL_ASSERT((boost::mpl::or_<
- boost::is_same<const value_type&, reference>,
- boost::is_same<value_type&, reference> >));
-
- reference ref = pmap[k];
- ignore_unused_variable_warning(ref);
- }
- PMap pmap;
- Key k;
- };
- template <typename KeyArchetype, typename ValueArchetype>
- struct lvalue_property_map_archetype
- : public readable_property_map_archetype<KeyArchetype, ValueArchetype>
- {
- typedef KeyArchetype key_type;
- typedef ValueArchetype value_type;
- typedef const ValueArchetype& reference;
- typedef lvalue_property_map_tag category;
- const value_type& operator[](const key_type&) const {
- return static_object<value_type>::get();
- }
- };
-
- template <class PMap, class Key>
- struct Mutable_LvaluePropertyMapConcept
- {
- typedef typename property_traits<PMap>::category Category;
- typedef boost::lvalue_property_map_tag LvalueTag;
- typedef typename property_traits<PMap>::reference reference;
- void constraints() {
- boost::function_requires< ReadWritePropertyMapConcept<PMap, Key> >();
- boost::function_requires<ConvertibleConcept<Category, LvalueTag> >();
-
- typedef typename property_traits<PMap>::value_type value_type;
- BOOST_MPL_ASSERT((boost::is_same<value_type&, reference>));
-
- reference ref = pmap[k];
- ignore_unused_variable_warning(ref);
- }
- PMap pmap;
- Key k;
- };
- template <typename KeyArchetype, typename ValueArchetype>
- struct mutable_lvalue_property_map_archetype
- : public readable_property_map_archetype<KeyArchetype, ValueArchetype>,
- public writable_property_map_archetype<KeyArchetype, ValueArchetype>
- {
- typedef KeyArchetype key_type;
- typedef ValueArchetype value_type;
- typedef ValueArchetype& reference;
- typedef lvalue_property_map_tag category;
- value_type& operator[](const key_type&) const {
- return static_object<value_type>::get();
- }
- };
-
- template <typename T>
- struct typed_identity_property_map;
-
- // A helper class for constructing a property map
- // from a class that implements operator[]
-
- template <class Reference, class LvaluePropertyMap>
- struct put_get_helper { };
-
- template <class PropertyMap, class Reference, class K>
- inline Reference
- get(const put_get_helper<Reference, PropertyMap>& pa, const K& k)
- {
- Reference v = static_cast<const PropertyMap&>(pa)[k];
- return v;
- }
- template <class PropertyMap, class Reference, class K, class V>
- inline void
- put(const put_get_helper<Reference, PropertyMap>& pa, K k, const V& v)
- {
- static_cast<const PropertyMap&>(pa)[k] = v;
- }
-
- //=========================================================================
- // Adapter to turn a RandomAccessIterator into a property map
-
- template <class RandomAccessIterator,
- class IndexMap
-#ifdef BOOST_NO_STD_ITERATOR_TRAITS
- , class T, class R
-#else
- , class T = typename std::iterator_traits<RandomAccessIterator>::value_type
- , class R = typename std::iterator_traits<RandomAccessIterator>::reference
-#endif
- >
- class iterator_property_map
- : public boost::put_get_helper< R,
- iterator_property_map<RandomAccessIterator, IndexMap,
- T, R> >
- {
- public:
- typedef typename property_traits<IndexMap>::key_type key_type;
- typedef T value_type;
- typedef R reference;
- typedef boost::lvalue_property_map_tag category;
-
- inline iterator_property_map(
- RandomAccessIterator cc = RandomAccessIterator(),
- const IndexMap& _id = IndexMap() )
- : iter(cc), index(_id) { }
- inline R operator[](key_type v) const { return *(iter + get(index, v)) ; }
- protected:
- RandomAccessIterator iter;
- IndexMap index;
- };
-
-#if !defined BOOST_NO_STD_ITERATOR_TRAITS
- template <class RAIter, class ID>
- inline iterator_property_map<
- RAIter, ID,
- typename std::iterator_traits<RAIter>::value_type,
- typename std::iterator_traits<RAIter>::reference>
- make_iterator_property_map(RAIter iter, ID id) {
- function_requires< RandomAccessIteratorConcept<RAIter> >();
- typedef iterator_property_map<
- RAIter, ID,
- typename std::iterator_traits<RAIter>::value_type,
- typename std::iterator_traits<RAIter>::reference> PA;
- return PA(iter, id);
- }
-#endif
- template <class RAIter, class Value, class ID>
- inline iterator_property_map<RAIter, ID, Value, Value&>
- make_iterator_property_map(RAIter iter, ID id, Value) {
- function_requires< RandomAccessIteratorConcept<RAIter> >();
- typedef iterator_property_map<RAIter, ID, Value, Value&> PMap;
- return PMap(iter, id);
- }
-
- template <class RandomAccessIterator,
- class IndexMap
-#ifdef BOOST_NO_STD_ITERATOR_TRAITS
- , class T, class R
-#else
- , class T = typename std::iterator_traits<RandomAccessIterator>::value_type
- , class R = typename std::iterator_traits<RandomAccessIterator>::reference
-#endif
- >
- class safe_iterator_property_map
- : public boost::put_get_helper< R,
- safe_iterator_property_map<RandomAccessIterator, IndexMap,
- T, R> >
- {
- public:
- typedef typename property_traits<IndexMap>::key_type key_type;
- typedef T value_type;
- typedef R reference;
- typedef boost::lvalue_property_map_tag category;
-
- inline safe_iterator_property_map(
- RandomAccessIterator first,
- std::size_t n_ = 0,
- const IndexMap& _id = IndexMap() )
- : iter(first), n(n_), index(_id) { }
- inline safe_iterator_property_map() { }
- inline R operator[](key_type v) const {
- BOOST_ASSERT(get(index, v) < n);
- return *(iter + get(index, v)) ;
- }
- typename property_traits<IndexMap>::value_type size() const { return n; }
- protected:
- RandomAccessIterator iter;
- typename property_traits<IndexMap>::value_type n;
- IndexMap index;
- };
-
- template <class RAIter, class ID>
- inline safe_iterator_property_map<
- RAIter, ID,
- typename boost::detail::iterator_traits<RAIter>::value_type,
- typename boost::detail::iterator_traits<RAIter>::reference>
- make_safe_iterator_property_map(RAIter iter, std::size_t n, ID id) {
- function_requires< RandomAccessIteratorConcept<RAIter> >();
- typedef safe_iterator_property_map<
- RAIter, ID,
- typename boost::detail::iterator_traits<RAIter>::value_type,
- typename boost::detail::iterator_traits<RAIter>::reference> PA;
- return PA(iter, n, id);
- }
- template <class RAIter, class Value, class ID>
- inline safe_iterator_property_map<RAIter, ID, Value, Value&>
- make_safe_iterator_property_map(RAIter iter, std::size_t n, ID id, Value) {
- function_requires< RandomAccessIteratorConcept<RAIter> >();
- typedef safe_iterator_property_map<RAIter, ID, Value, Value&> PMap;
- return PMap(iter, n, id);
- }
-
- //=========================================================================
- // An adaptor to turn a Unique Pair Associative Container like std::map or
- // std::hash_map into an Lvalue Property Map.
-
- template <typename UniquePairAssociativeContainer>
- class associative_property_map
- : public boost::put_get_helper<
- typename UniquePairAssociativeContainer::value_type::second_type&,
- associative_property_map<UniquePairAssociativeContainer> >
- {
- typedef UniquePairAssociativeContainer C;
- public:
- typedef typename C::key_type key_type;
- typedef typename C::value_type::second_type value_type;
- typedef value_type& reference;
- typedef lvalue_property_map_tag category;
- associative_property_map() : m_c(0) { }
- associative_property_map(C& c) : m_c(&c) { }
- reference operator[](const key_type& k) const {
- return (*m_c)[k];
- }
- private:
- C* m_c;
- };
-
- template <class UniquePairAssociativeContainer>
- associative_property_map<UniquePairAssociativeContainer>
- make_assoc_property_map(UniquePairAssociativeContainer& c)
- {
- return associative_property_map<UniquePairAssociativeContainer>(c);
- }
-
- template <typename UniquePairAssociativeContainer>
- class const_associative_property_map
- : public boost::put_get_helper<
- const typename UniquePairAssociativeContainer::value_type::second_type&,
- const_associative_property_map<UniquePairAssociativeContainer> >
- {
- typedef UniquePairAssociativeContainer C;
- public:
- typedef typename C::key_type key_type;
- typedef typename C::value_type::second_type value_type;
- typedef const value_type& reference;
- typedef lvalue_property_map_tag category;
- const_associative_property_map() : m_c(0) { }
- const_associative_property_map(const C& c) : m_c(&c) { }
- reference operator[](const key_type& k) const {
- return m_c->find(k)->second;
- }
- private:
- C const* m_c;
- };
-
- template <class UniquePairAssociativeContainer>
- const_associative_property_map<UniquePairAssociativeContainer>
- make_assoc_property_map(const UniquePairAssociativeContainer& c)
- {
- return const_associative_property_map<UniquePairAssociativeContainer>(c);
- }
-
- //=========================================================================
- // A property map that always returns the same object by value.
- //
- template <typename ValueType>
- class static_property_map :
- public
- boost::put_get_helper<ValueType,static_property_map<ValueType> >
- {
- ValueType value;
- public:
- typedef void key_type;
- typedef ValueType value_type;
- typedef ValueType reference;
- typedef readable_property_map_tag category;
- static_property_map(ValueType v) : value(v) {}
-
- template<typename T>
- inline reference operator[](T) const { return value; }
- };
-
- //=========================================================================
- // A property map that always returns a reference to the same object.
- //
- template <typename KeyType, typename ValueType>
- class ref_property_map :
- public
- boost::put_get_helper<ValueType&,ref_property_map<KeyType,ValueType> >
- {
- ValueType* value;
- public:
- typedef KeyType key_type;
- typedef ValueType value_type;
- typedef ValueType& reference;
- typedef lvalue_property_map_tag category;
- ref_property_map(ValueType& v) : value(&v) {}
- ValueType& operator[](key_type const&) const { return *value; }
- };
-
- //=========================================================================
- // A generalized identity property map
- template <typename T>
- struct typed_identity_property_map
- : public boost::put_get_helper<T, typed_identity_property_map<T> >
- {
- typedef T key_type;
- typedef T value_type;
- typedef T reference;
- typedef boost::readable_property_map_tag category;
-
- inline value_type operator[](const key_type& v) const { return v; }
- };
-
-//=========================================================================
- // A property map that applies the identity function to integers
- typedef typed_identity_property_map<std::size_t> identity_property_map;
-
- //=========================================================================
- // A property map that does not do anything, for
- // when you have to supply a property map, but don't need it.
- namespace detail {
- struct dummy_pmap_reference {
- template <class T>
- dummy_pmap_reference& operator=(const T&) { return *this; }
- operator int() { return 0; }
- };
- }
- class dummy_property_map
- : public boost::put_get_helper<detail::dummy_pmap_reference,
- dummy_property_map >
- {
- public:
- typedef void key_type;
- typedef int value_type;
- typedef detail::dummy_pmap_reference reference;
- typedef boost::read_write_property_map_tag category;
- inline dummy_property_map() : c(0) { }
- inline dummy_property_map(value_type cc) : c(cc) { }
- inline dummy_property_map(const dummy_property_map& x)
- : c(x.c) { }
- template <class Vertex>
- inline reference operator[](Vertex) const { return reference(); }
- protected:
- value_type c;
- };
-
- // Convert a Readable property map into a function object
- template <typename PropMap>
- class property_map_function {
- PropMap pm;
- typedef typename property_traits<PropMap>::key_type param_type;
- public:
- explicit property_map_function(const PropMap& pm): pm(pm) {}
- typedef typename property_traits<PropMap>::value_type result_type;
- result_type operator()(const param_type& k) const {return get(pm, k);}
- };
-
- template <typename PropMap>
- property_map_function<PropMap>
- make_property_map_function(const PropMap& pm) {
- return property_map_function<PropMap>(pm);
- }
-
-} // namespace boost
-
-#ifdef BOOST_GRAPH_USE_MPI
#include <boost/property_map/parallel/distributed_property_map.hpp>
#include <boost/property_map/parallel/local_property_map.hpp>

@@ -785,9 +226,8 @@
};

}
-#endif // BOOST_GRAPH_USE_MPI

#include <boost/property_map/vector_property_map.hpp>

-#endif /* BOOST_PROPERTY_MAP_HPP */
+#endif /* BOOST_PROPERTY_MAP_PARALLEL_PROPERTY_MAPS_HPP */

Copied and modified: trunk/boost/property_map/parallel/process_group.hpp (from r86380, trunk/boost/graph/parallel/process_group.hpp)
==============================================================================
--- trunk/boost/graph/parallel/process_group.hpp Mon Oct 21 08:26:30 2013 (r86380, copy source)
+++ trunk/boost/property_map/parallel/process_group.hpp 2013-10-21 14:29:04 EDT (Mon, 21 Oct 2013) (r86381)
@@ -6,17 +6,13 @@

// Authors: Douglas Gregor
// Andrew Lumsdaine
-#ifndef BOOST_GRAPH_PARALLEL_PROCESS_GROUP_HPP
-#define BOOST_GRAPH_PARALLEL_PROCESS_GROUP_HPP
-
-#ifndef BOOST_GRAPH_USE_MPI
-#error "Parallel BGL files should not be included unless <boost/graph/use_mpi.hpp> has been included"
-#endif
+#ifndef BOOST_PROPERTY_MAP_PARALLEL_PROCESS_GROUP_HPP
+#define BOOST_PROPERTY_MAP_PARALLEL_PROCESS_GROUP_HPP

#include <cstdlib>
#include <utility>

-namespace boost { namespace graph { namespace parallel {
+namespace boost { namespace parallel {

/**
  * A special type used as a flag to a process group constructor that
@@ -86,16 +82,16 @@
         process_group_archetype::process_id_type source, int tag, T values[],
         std::size_t n);

-} } } // end namespace boost::graph::parallel
+} } // end namespace boost::parallel

namespace boost { namespace graph { namespace distributed {
- using parallel::trigger_receive_context;
- using parallel::trc_early_receive;
- using parallel::trc_out_of_band;
- using parallel::trc_irecv_out_of_band;
- using parallel::trc_in_synchronization;
- using parallel::trc_none;
- using parallel::attach_distributed_object;
+ using boost::parallel::trigger_receive_context;
+ using boost::parallel::trc_early_receive;
+ using boost::parallel::trc_out_of_band;
+ using boost::parallel::trc_irecv_out_of_band;
+ using boost::parallel::trc_in_synchronization;
+ using boost::parallel::trc_none;
+ using boost::parallel::attach_distributed_object;
} } } // end namespace boost::graph::distributed

-#endif // BOOST_GRAPH_PARALLEL_PROCESS_GROUP_HPP
+#endif // BOOST_PROPERTY_MAP_PARALLEL_PROCESS_GROUP_HPP

Copied and modified: trunk/boost/property_map/parallel/simple_trigger.hpp (from r86380, trunk/boost/graph/parallel/simple_trigger.hpp)
==============================================================================
--- trunk/boost/graph/parallel/simple_trigger.hpp Mon Oct 21 08:26:30 2013 (r86380, copy source)
+++ trunk/boost/property_map/parallel/simple_trigger.hpp 2013-10-21 14:29:04 EDT (Mon, 21 Oct 2013) (r86381)
@@ -9,16 +9,12 @@
// the handler associated with a trigger is a member function bound to
// a particular pointer.

-#ifndef BOOST_GRAPH_PARALLEL_SIMPLE_TRIGGER_HPP
-#define BOOST_GRAPH_PARALLEL_SIMPLE_TRIGGER_HPP
+#ifndef BOOST_PROPERTY_MAP_PARALLEL_SIMPLE_TRIGGER_HPP
+#define BOOST_PROPERTY_MAP_PARALLEL_SIMPLE_TRIGGER_HPP

-#ifndef BOOST_GRAPH_USE_MPI
-#error "Parallel BGL files should not be included unless <boost/graph/use_mpi.hpp> has been included"
-#endif
+#include <boost/property_map/parallel/process_group.hpp>

-#include <boost/graph/parallel/process_group.hpp>
-
-namespace boost { namespace graph { namespace parallel {
+namespace boost { namespace parallel {

namespace detail {

@@ -103,6 +99,8 @@
simple_trigger(pg, tag, self, pmf, 0);
}

-} } } // end namespace boost::graph::parallel
+} } // end namespace boost::parallel
+
+namespace boost { namespace graph { namespace parallel { using boost::parallel::simple_trigger; } } }

-#endif // BOOST_GRAPH_PARALLEL_SIMPLE_TRIGGER_HPP
+#endif // BOOST_PROPERTY_MAP_PARALLEL_SIMPLE_TRIGGER_HPP

Copied and modified: trunk/boost/property_map/parallel/unsafe_serialize.hpp (from r86380, trunk/boost/graph/distributed/unsafe_serialize.hpp)
==============================================================================
--- trunk/boost/graph/distributed/unsafe_serialize.hpp Mon Oct 21 08:26:30 2013 (r86380, copy source)
+++ trunk/boost/property_map/parallel/unsafe_serialize.hpp 2013-10-21 14:29:04 EDT (Mon, 21 Oct 2013) (r86381)
@@ -10,12 +10,8 @@
// This file contains the "unsafe_serialize" routine, which transforms
// types they may not be serializable (such as void*) into
// serializable equivalents.
-#ifndef PBGL_UNSAFE_SERIALIZE_HPP
-#define PBGL_UNSAFE_SERIALIZE_HPP
-
-#ifndef BOOST_GRAPH_USE_MPI
-#error "Parallel BGL files should not be included unless <boost/graph/use_mpi.hpp> has been included"
-#endif
+#ifndef BOOST_PROPERTY_MAP_UNSAFE_SERIALIZE_HPP
+#define BOOST_PROPERTY_MAP_UNSAFE_SERIALIZE_HPP

#include <boost/mpi/datatype.hpp>
#include <boost/serialization/is_bitwise_serializable.hpp>
@@ -82,4 +78,4 @@

} // end namespace boost

-#endif // PBGL_UNSAFE_SERIALIZE_HPP
+#endif // BOOST_PROPERTY_MAP_UNSAFE_SERIALIZE_HPP

Modified: trunk/boost/property_map/property_map.hpp
==============================================================================
--- trunk/boost/property_map/property_map.hpp Mon Oct 21 08:26:30 2013 (r86380)
+++ trunk/boost/property_map/property_map.hpp 2013-10-21 14:29:04 EDT (Mon, 21 Oct 2013) (r86381)
@@ -588,204 +588,8 @@
} // namespace boost

#ifdef BOOST_GRAPH_USE_MPI
-#include <boost/property_map/parallel/distributed_property_map.hpp>
-#include <boost/property_map/parallel/local_property_map.hpp>
-
-namespace boost {
-/** Distributed iterator property map.
- *
- * This specialization of @ref iterator_property_map builds a
- * distributed iterator property map given the local index maps
- * generated by distributed graph types that automatically have index
- * properties.
- *
- * This specialization is useful when creating external distributed
- * property maps via the same syntax used to create external
- * sequential property maps.
- */
-template<typename RandomAccessIterator, typename ProcessGroup,
- typename GlobalMap, typename StorageMap,
- typename ValueType, typename Reference>
-class iterator_property_map
- <RandomAccessIterator,
- local_property_map<ProcessGroup, GlobalMap, StorageMap>,
- ValueType, Reference>
- : public parallel::distributed_property_map
- <ProcessGroup,
- GlobalMap,
- iterator_property_map<RandomAccessIterator, StorageMap,
- ValueType, Reference> >
-{
- typedef iterator_property_map<RandomAccessIterator, StorageMap,
- ValueType, Reference> local_iterator_map;
-
- typedef parallel::distributed_property_map<ProcessGroup, GlobalMap,
- local_iterator_map> inherited;
-
- typedef local_property_map<ProcessGroup, GlobalMap, StorageMap>
- index_map_type;
- typedef iterator_property_map self_type;
-
-public:
- iterator_property_map() { }
-
- iterator_property_map(RandomAccessIterator cc, const index_map_type& id)
- : inherited(id.process_group(), id.global(),
- local_iterator_map(cc, id.base())) { }
-};
-
-/** Distributed iterator property map.
- *
- * This specialization of @ref iterator_property_map builds a
- * distributed iterator property map given a distributed index
- * map. Only the local portion of the distributed index property map
- * is utilized.
- *
- * This specialization is useful when creating external distributed
- * property maps via the same syntax used to create external
- * sequential property maps.
- */
-template<typename RandomAccessIterator, typename ProcessGroup,
- typename GlobalMap, typename StorageMap,
- typename ValueType, typename Reference>
-class iterator_property_map<
- RandomAccessIterator,
- parallel::distributed_property_map<ProcessGroup,GlobalMap,StorageMap>,
- ValueType, Reference
- >
- : public parallel::distributed_property_map
- <ProcessGroup,
- GlobalMap,
- iterator_property_map<RandomAccessIterator, StorageMap,
- ValueType, Reference> >
-{
- typedef iterator_property_map<RandomAccessIterator, StorageMap,
- ValueType, Reference> local_iterator_map;
-
- typedef parallel::distributed_property_map<ProcessGroup, GlobalMap,
- local_iterator_map> inherited;
-
- typedef parallel::distributed_property_map<ProcessGroup, GlobalMap,
- StorageMap>
- index_map_type;
-
-public:
- iterator_property_map() { }
-
- iterator_property_map(RandomAccessIterator cc, const index_map_type& id)
- : inherited(id.process_group(), id.global(),
- local_iterator_map(cc, id.base())) { }
-};
-
-namespace parallel {
-// Generate an iterator property map with a specific kind of ghost
-// cells
-template<typename RandomAccessIterator, typename ProcessGroup,
- typename GlobalMap, typename StorageMap>
-distributed_property_map<ProcessGroup,
- GlobalMap,
- iterator_property_map<RandomAccessIterator,
- StorageMap> >
-make_iterator_property_map(RandomAccessIterator cc,
- local_property_map<ProcessGroup, GlobalMap,
- StorageMap> index_map)
-{
- typedef distributed_property_map<
- ProcessGroup, GlobalMap,
- iterator_property_map<RandomAccessIterator, StorageMap> >
- result_type;
- return result_type(index_map.process_group(), index_map.global(),
- make_iterator_property_map(cc, index_map.base()));
-}
-
-} // end namespace parallel
-
-/** Distributed safe iterator property map.
- *
- * This specialization of @ref safe_iterator_property_map builds a
- * distributed iterator property map given the local index maps
- * generated by distributed graph types that automatically have index
- * properties.
- *
- * This specialization is useful when creating external distributed
- * property maps via the same syntax used to create external
- * sequential property maps.
- */
-template<typename RandomAccessIterator, typename ProcessGroup,
- typename GlobalMap, typename StorageMap, typename ValueType,
- typename Reference>
-class safe_iterator_property_map
- <RandomAccessIterator,
- local_property_map<ProcessGroup, GlobalMap, StorageMap>,
- ValueType, Reference>
- : public parallel::distributed_property_map
- <ProcessGroup,
- GlobalMap,
- safe_iterator_property_map<RandomAccessIterator, StorageMap,
- ValueType, Reference> >
-{
- typedef safe_iterator_property_map<RandomAccessIterator, StorageMap,
- ValueType, Reference> local_iterator_map;
-
- typedef parallel::distributed_property_map<ProcessGroup, GlobalMap,
- local_iterator_map> inherited;
-
- typedef local_property_map<ProcessGroup, GlobalMap, StorageMap> index_map_type;
-
-public:
- safe_iterator_property_map() { }
-
- safe_iterator_property_map(RandomAccessIterator cc, std::size_t n,
- const index_map_type& id)
- : inherited(id.process_group(), id.global(),
- local_iterator_map(cc, n, id.base())) { }
-};
-
-/** Distributed safe iterator property map.
- *
- * This specialization of @ref safe_iterator_property_map builds a
- * distributed iterator property map given a distributed index
- * map. Only the local portion of the distributed index property map
- * is utilized.
- *
- * This specialization is useful when creating external distributed
- * property maps via the same syntax used to create external
- * sequential property maps.
- */
-template<typename RandomAccessIterator, typename ProcessGroup,
- typename GlobalMap, typename StorageMap,
- typename ValueType, typename Reference>
-class safe_iterator_property_map<
- RandomAccessIterator,
- parallel::distributed_property_map<ProcessGroup,GlobalMap,StorageMap>,
- ValueType, Reference>
- : public parallel::distributed_property_map
- <ProcessGroup,
- GlobalMap,
- safe_iterator_property_map<RandomAccessIterator, StorageMap,
- ValueType, Reference> >
-{
- typedef safe_iterator_property_map<RandomAccessIterator, StorageMap,
- ValueType, Reference> local_iterator_map;
-
- typedef parallel::distributed_property_map<ProcessGroup, GlobalMap,
- local_iterator_map> inherited;
-
- typedef parallel::distributed_property_map<ProcessGroup, GlobalMap,
- StorageMap>
- index_map_type;
-
-public:
- safe_iterator_property_map() { }
-
- safe_iterator_property_map(RandomAccessIterator cc, std::size_t n,
- const index_map_type& id)
- : inherited(id.process_group(), id.global(),
- local_iterator_map(cc, n, id.base())) { }
-};
-
-}
-#endif // BOOST_GRAPH_USE_MPI
+#include <boost/property_map/parallel/parallel_property_maps.hpp>
+#endif

#include <boost/property_map/vector_property_map.hpp>

Date view	Thread view	Subject view	Author view

Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk