// Copyright (C) 2007 Douglas Gregor and Matthias Troyer | |
// | |
// Use, modification and distribution is subject to the Boost Software | |
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at | |
// | |
// 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_PROPERTY_HOLDERS_HPP | |
#define BOOST_PARALLEL_DETAIL_PROPERTY_HOLDERS_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/property_map/property_map.hpp> | |
#include <boost/serialization/base_object.hpp> | |
#include <boost/mpl/and.hpp> | |
#include <boost/graph/parallel/detail/untracked_pair.hpp> | |
namespace boost { namespace detail { namespace parallel { | |
/** | |
* This structure contains an instance of @c Property, unless @c | |
* Property is a placeholder for "no property". Always access the | |
* property through @c get_property. Typically used as a base class. | |
*/ | |
template<typename Property> | |
struct maybe_store_property | |
{ | |
maybe_store_property() {} | |
maybe_store_property(const Property& p) : p(p) {} | |
Property& get_property() { return p; } | |
const Property& get_property() const { return p; } | |
private: | |
Property p; | |
friend class boost::serialization::access; | |
template<typename Archiver> | |
void serialize(Archiver& ar, const unsigned int /*version*/) | |
{ | |
ar & p; | |
} | |
}; | |
template<> | |
struct maybe_store_property<no_property> | |
{ | |
maybe_store_property() {} | |
maybe_store_property(no_property) {} | |
no_property get_property() const { return no_property(); } | |
private: | |
friend class boost::serialization::access; | |
template<typename Archiver> | |
void serialize(Archiver&, const unsigned int /*version*/) { } | |
}; | |
/** | |
* This structure is a simple pair that also contains a property. | |
*/ | |
template<typename T, typename U, typename Property> | |
class pair_with_property | |
: public boost::parallel::detail::untracked_pair<T, U> | |
, public maybe_store_property<Property> | |
{ | |
public: | |
typedef boost::parallel::detail::untracked_pair<T, U> pair_base; | |
typedef maybe_store_property<Property> property_base; | |
pair_with_property() { } | |
pair_with_property(const T& t, const U& u, const Property& property) | |
: pair_base(t, u), property_base(property) { } | |
private: | |
friend class boost::serialization::access; | |
template<typename Archiver> | |
void serialize(Archiver& ar, const unsigned int /*version*/) | |
{ | |
ar & boost::serialization::base_object<pair_base>(*this) | |
& boost::serialization::base_object<property_base>(*this); | |
} | |
}; | |
template<typename T, typename U, typename Property> | |
inline pair_with_property<T, U, Property> | |
make_pair_with_property(const T& t, const U& u, const Property& property) | |
{ | |
return pair_with_property<T, U, Property>(t, u, property); | |
} | |
} } } // end namespace boost::parallel::detail | |
namespace boost { namespace mpi { | |
template<> | |
struct is_mpi_datatype<boost::detail::parallel::maybe_store_property<no_property> > : mpl::true_ { }; | |
template<typename Property> | |
struct is_mpi_datatype<boost::detail::parallel::maybe_store_property<Property> > | |
: is_mpi_datatype<Property> { }; | |
template<typename T, typename U, typename Property> | |
struct is_mpi_datatype<boost::detail::parallel::pair_with_property<T, U, Property> > | |
: boost::mpl::and_<is_mpi_datatype<boost::parallel::detail::untracked_pair<T, U> >, | |
is_mpi_datatype<Property> > { }; | |
} } // end namespace boost::mpi | |
BOOST_IS_BITWISE_SERIALIZABLE(boost::detail::parallel::maybe_store_property<no_property>) | |
namespace boost { namespace serialization { | |
template<typename Property> | |
struct is_bitwise_serializable<boost::detail::parallel::maybe_store_property<Property> > | |
: is_bitwise_serializable<Property> { }; | |
template<typename Property> | |
struct implementation_level<boost::detail::parallel::maybe_store_property<Property> > | |
: mpl::int_<object_serializable> {} ; | |
template<typename Property> | |
struct tracking_level<boost::detail::parallel::maybe_store_property<Property> > | |
: mpl::int_<track_never> {} ; | |
template<typename T, typename U, typename Property> | |
struct is_bitwise_serializable< | |
boost::detail::parallel::pair_with_property<T, U, Property> > | |
: boost::mpl::and_<is_bitwise_serializable<boost::parallel::detail::untracked_pair<T, U> >, | |
is_bitwise_serializable<Property> > { }; | |
template<typename T, typename U, typename Property> | |
struct implementation_level< | |
boost::detail::parallel::pair_with_property<T, U, Property> > | |
: mpl::int_<object_serializable> {} ; | |
template<typename T, typename U, typename Property> | |
struct tracking_level< | |
boost::detail::parallel::pair_with_property<T, U, Property> > | |
: mpl::int_<track_never> {} ; | |
} } // end namespace boost::serialization | |
#endif // BOOST_PARALLEL_DETAIL_PROPERTY_HOLDERS_HPP |