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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
|
// Boost.Geometry Index
//
// Copyright (c) 2011-2014 Adam Wulkiewicz, Lodz, Poland.
//
// 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)
#ifndef BOOST_GEOMETRY_INDEX_EQUAL_TO_HPP
#define BOOST_GEOMETRY_INDEX_EQUAL_TO_HPP
#include <boost/geometry/algorithms/equals.hpp>
#include <boost/geometry/index/indexable.hpp>
namespace boost { namespace geometry { namespace index { namespace detail {
template <typename Geometry,
typename Tag = typename geometry::tag<Geometry>::type>
struct equals
{
inline static bool apply(Geometry const& g1, Geometry const& g2)
{
return geometry::equals(g1, g2);
}
};
template <typename T>
struct equals<T, void>
{
inline static bool apply(T const& v1, T const& v2)
{
return v1 == v2;
}
};
template <typename Tuple, size_t I, size_t N>
struct tuple_equals
{
inline static bool apply(Tuple const& t1, Tuple const& t2)
{
typedef typename boost::tuples::element<I, Tuple>::type T;
return equals<T>::apply(boost::get<I>(t1), boost::get<I>(t2))
&& tuple_equals<Tuple, I+1, N>::apply(t1, t2);
}
};
template <typename Tuple, size_t I>
struct tuple_equals<Tuple, I, I>
{
inline static bool apply(Tuple const&, Tuple const&)
{
return true;
}
};
// TODO: Consider this: Since equal_to<> is using geometry::equals() it's possible that
// two compared Indexables are not exactly the same! They will be spatially equal
// but not strictly equal. Consider 2 Segments with reversed order of points.
// Therefore it's possible that during the Value removal different value will be
// removed than the one that was passed.
/*!
\brief The function object comparing Values.
It compares Geometries using geometry::equals() function. Other types are compared using operator==.
The default version handles Values which are Indexables.
This template is also specialized for std::pair<T1, T2> and boost::tuple<...>.
\tparam Value The type of objects which are compared by this function object.
\tparam IsIndexable If true, Values are compared using boost::geometry::equals() functions.
*/
template <typename Value,
bool IsIndexable = is_indexable<Value>::value>
struct equal_to
{
/*! \brief The type of result returned by function object. */
typedef bool result_type;
/*!
\brief Compare values. If Value is a Geometry geometry::equals() function is used.
\param l First value.
\param r Second value.
\return true if values are equal.
*/
inline bool operator()(Value const& l, Value const& r) const
{
return detail::equals<Value>::apply(l ,r);
}
};
/*!
\brief The function object comparing Values.
This specialization compares values of type std::pair<T1, T2>.
It compares pairs' first values, then second values.
\tparam T1 The first type.
\tparam T2 The second type.
*/
template <typename T1, typename T2>
struct equal_to<std::pair<T1, T2>, false>
{
/*! \brief The type of result returned by function object. */
typedef bool result_type;
/*!
\brief Compare values. If pair<> Value member is a Geometry geometry::equals() function is used.
\param l First value.
\param r Second value.
\return true if values are equal.
*/
inline bool operator()(std::pair<T1, T2> const& l, std::pair<T1, T2> const& r) const
{
return detail::equals<T1>::apply(l.first, r.first)
&& detail::equals<T2>::apply(l.second, r.second);
}
};
/*!
\brief The function object comparing Values.
This specialization compares values of type boost::tuple<...>.
It compares all members of the tuple from the first one to the last one.
*/
template <typename T0, typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6, typename T7, typename T8, typename T9>
struct equal_to<boost::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>, false>
{
typedef boost::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> value_type;
/*! \brief The type of result returned by function object. */
typedef bool result_type;
/*!
\brief Compare values. If tuple<> Value member is a Geometry geometry::equals() function is used.
\param l First value.
\param r Second value.
\return true if values are equal.
*/
inline bool operator()(value_type const& l, value_type const& r) const
{
return detail::tuple_equals<
value_type, 0, boost::tuples::length<value_type>::value
>::apply(l ,r);
}
};
}}}} // namespace boost::geometry::index::detail
#if !defined(BOOST_NO_CXX11_HDR_TUPLE) && !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
#include <tuple>
namespace boost { namespace geometry { namespace index { namespace detail {
template <typename Tuple, size_t I, size_t N>
struct std_tuple_equals
{
inline static bool apply(Tuple const& t1, Tuple const& t2)
{
typedef typename std::tuple_element<I, Tuple>::type T;
return equals<T>::apply(std::get<I>(t1), std::get<I>(t2))
&& std_tuple_equals<Tuple, I+1, N>::apply(t1, t2);
}
};
template <typename Tuple, size_t I>
struct std_tuple_equals<Tuple, I, I>
{
inline static bool apply(Tuple const&, Tuple const&)
{
return true;
}
};
/*!
\brief The function object comparing Values.
This specialization compares values of type std::tuple<Args...>.
It's defined if the compiler supports tuples and variadic templates.
It compares all members of the tuple from the first one to the last one.
*/
template <typename ...Args>
struct equal_to<std::tuple<Args...>, false>
{
typedef std::tuple<Args...> value_type;
/*! \brief The type of result returned by function object. */
typedef bool result_type;
/*!
\brief Compare values. If tuple<> Value member is a Geometry geometry::equals() function is used.
\param l First value.
\param r Second value.
\return true if values are equal.
*/
bool operator()(value_type const& l, value_type const& r) const
{
return detail::std_tuple_equals<
value_type, 0, std::tuple_size<value_type>::value
>::apply(l ,r);
}
};
}}}} // namespace boost::geometry::index::detail
#endif // !defined(BOOST_NO_CXX11_HDR_TUPLE) && !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
namespace boost { namespace geometry { namespace index {
/*!
\brief The function object comparing Values.
The default version handles Values which are Indexables, std::pair<T1, T2>, boost::tuple<...>
and std::tuple<...> if STD tuples and variadic templates are supported.
All members are compared from left to right, Geometries using boost::geometry::equals() function,
other types using operator==.
\tparam Value The type of objects which are compared by this function object.
*/
template <typename Value>
struct equal_to
: detail::equal_to<Value>
{
/*! \brief The type of result returned by function object. */
typedef typename detail::equal_to<Value>::result_type result_type;
/*!
\brief Compare Values.
\param l First value.
\param r Second value.
\return true if Values are equal.
*/
inline bool operator()(Value const& l, Value const& r) const
{
return detail::equal_to<Value>::operator()(l ,r);
}
};
}}} // namespace boost::geometry::index
#endif // BOOST_GEOMETRY_INDEX_EQUAL_TO_HPP
|
