63e88f80
 Hu Chunming
提交三方库
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
|
// Copyright 2004 The Trustees of Indiana University.
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
// Authors: Douglas Gregor
// Andrew Lumsdaine
#ifndef BOOST_GRAPH_PARALLEL_PROPERTIES_HPP
#define BOOST_GRAPH_PARALLEL_PROPERTIES_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/properties.hpp>
#include <boost/property_map/parallel/distributed_property_map.hpp>
namespace boost {
/***************************************************************************
* Property map reduction operations
***************************************************************************/
/**
* Metafunction that produces a reduction operation for the given
* property. The default behavior merely forwards to @ref
* basic_reduce, but it is expected that this class template will be
* specified for important properties.
*/
template<typename Property>
struct property_reduce
{
template<typename Value>
class apply : public parallel::basic_reduce<Value> {};
};
/**
* Reduction of vertex colors can only darken, not lighten, the
* color. Black cannot turn black, grey can only turn black, and
* white can be changed to either color. The default color is white.
*/
template<>
struct property_reduce<vertex_color_t>
{
template<typename Color>
class apply
{
typedef color_traits<Color> traits;
public:
BOOST_STATIC_CONSTANT(bool, non_default_resolver = true);
template<typename Key>
Color operator()(const Key&) const { return traits::white(); }
template<typename Key>
Color operator()(const Key&, Color local, Color remote) const {
if (local == traits::white()) return remote;
else if (remote == traits::black()) return remote;
else return local;
}
};
};
/**
* Reduction of a distance always takes the shorter distance. The
* default distance value is the maximum value for the data type.
*/
template<>
struct property_reduce<vertex_distance_t>
{
template<typename T>
class apply
{
public:
BOOST_STATIC_CONSTANT(bool, non_default_resolver = true);
template<typename Key>
T operator()(const Key&) const { return (std::numeric_limits<T>::max)(); }
template<typename Key>
T operator()(const Key&, T x, T y) const { return x < y? x : y; }
};
};
template<>
struct property_reduce<vertex_predecessor_t>
{
template<typename T>
class apply
{
public:
BOOST_STATIC_CONSTANT(bool, non_default_resolver = true);
template<typename Key>
T operator()(Key key) const { return key; }
template<typename Key>
T operator()(Key key, T, T y) const { return y; }
};
};
template<typename Property, typename PropertyMap>
inline void set_property_map_role(Property p, PropertyMap pm)
{
typedef typename property_traits<PropertyMap>::value_type value_type;
typedef property_reduce<Property> property_red;
typedef typename property_red::template apply<value_type> reduce;
pm.set_reduce(reduce());
}
} // end namespace boost
#endif // BOOST_GRAPH_PARALLEL_PROPERTIES_HPP
|
