| // (C) Copyright Jeremy Siek 1999-2001. |
| // Copyright (C) 2006 Trustees of Indiana University |
| // Authors: Douglas Gregor and Jeremy Siek |
| |
| // 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) |
| |
| // See http://www.boost.org/libs/property_map for documentation. |
| |
| #ifndef BOOST_PROPERTY_MAP_HPP |
| #define BOOST_PROPERTY_MAP_HPP |
| |
| #include <cassert> |
| #include <boost/config.hpp> |
| #include <boost/pending/cstddef.hpp> |
| #include <boost/detail/iterator.hpp> |
| #include <boost/concept_check.hpp> |
| #include <boost/concept_archetype.hpp> |
| #include <boost/mpl/assert.hpp> |
| #include <boost/mpl/or.hpp> |
| #include <boost/mpl/and.hpp> |
| #include <boost/mpl/has_xxx.hpp> |
| #include <boost/type_traits/is_same.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 |
| |
| #ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION |
| // The user will just have to create their own specializations for |
| // other pointers types if the compiler does not have partial |
| // specializations. Sorry! |
| #define BOOST_SPECIALIZE_PROPERTY_TRAITS_PTR(TYPE) \ |
| template <> \ |
| struct property_traits<TYPE*> { \ |
| typedef TYPE value_type; \ |
| typedef value_type& reference; \ |
| typedef std::ptrdiff_t key_type; \ |
| typedef lvalue_property_map_tag category; \ |
| }; \ |
| template <> \ |
| struct property_traits<const TYPE*> { \ |
| typedef TYPE value_type; \ |
| typedef const value_type& reference; \ |
| typedef std::ptrdiff_t key_type; \ |
| typedef lvalue_property_map_tag category; \ |
| } |
| |
| BOOST_SPECIALIZE_PROPERTY_TRAITS_PTR(long); |
| BOOST_SPECIALIZE_PROPERTY_TRAITS_PTR(unsigned long); |
| BOOST_SPECIALIZE_PROPERTY_TRAITS_PTR(int); |
| BOOST_SPECIALIZE_PROPERTY_TRAITS_PTR(unsigned int); |
| BOOST_SPECIALIZE_PROPERTY_TRAITS_PTR(short); |
| BOOST_SPECIALIZE_PROPERTY_TRAITS_PTR(unsigned short); |
| BOOST_SPECIALIZE_PROPERTY_TRAITS_PTR(char); |
| BOOST_SPECIALIZE_PROPERTY_TRAITS_PTR(unsigned char); |
| BOOST_SPECIALIZE_PROPERTY_TRAITS_PTR(signed char); |
| BOOST_SPECIALIZE_PROPERTY_TRAITS_PTR(bool); |
| BOOST_SPECIALIZE_PROPERTY_TRAITS_PTR(float); |
| BOOST_SPECIALIZE_PROPERTY_TRAITS_PTR(double); |
| BOOST_SPECIALIZE_PROPERTY_TRAITS_PTR(long double); |
| |
| // This may need to be turned off for some older compilers that don't have |
| // wchar_t intrinsically. |
| # ifndef BOOST_NO_INTRINSIC_WCHAR_T |
| template <> |
| struct property_traits<wchar_t*> { |
| typedef wchar_t value_type; |
| typedef value_type& reference; |
| typedef std::ptrdiff_t key_type; |
| typedef lvalue_property_map_tag category; |
| }; |
| template <> |
| struct property_traits<const wchar_t*> { |
| typedef wchar_t value_type; |
| typedef const value_type& reference; |
| typedef std::ptrdiff_t key_type; |
| typedef lvalue_property_map_tag category; |
| }; |
| # endif |
| |
| #else |
| template <class T> |
| struct property_traits<T*> { |
| 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*> { |
| typedef T value_type; |
| typedef const value_type& reference; |
| typedef std::ptrdiff_t key_type; |
| typedef lvalue_property_map_tag category; |
| }; |
| #endif |
| |
| #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 { |
| 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; |
| }; |
| |
| #if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION |
| 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); |
| } |
| #endif |
| 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> |
| |
| 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/vector_property_map.hpp> |
| |
| #endif /* BOOST_PROPERTY_MAP_HPP */ |
| |