Boost.Geometry.Index
 All Classes Functions Typedefs Groups
equal_to.hpp
1 // Boost.Geometry Index
2 //
3 // Copyright (c) 2011-2016 Adam Wulkiewicz, Lodz, Poland.
4 //
5 // Use, modification and distribution is subject to the Boost Software License,
6 // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
7 // http://www.boost.org/LICENSE_1_0.txt)
8 
9 #ifndef BOOST_GEOMETRY_INDEX_EQUAL_TO_HPP
10 #define BOOST_GEOMETRY_INDEX_EQUAL_TO_HPP
11 
12 #include <boost/geometry/algorithms/equals.hpp>
13 #include <boost/geometry/index/indexable.hpp>
14 
15 namespace boost { namespace geometry { namespace index { namespace detail {
16 
17 template <typename Geometry,
18  typename Tag = typename geometry::tag<Geometry>::type>
19 struct equals
20 {
21  inline static bool apply(Geometry const& g1, Geometry const& g2)
22  {
23  return geometry::equals(g1, g2);
24  }
25 };
26 
27 template <typename Geometry, typename Tag>
28 struct equals<Geometry *, Tag>
29 {
30  inline static bool apply(const Geometry * g1, const Geometry * g2)
31  {
32  return g1 == g2;
33  }
34 };
35 
36 template <typename T>
37 struct equals<T, void>
38 {
39  inline static bool apply(T const& v1, T const& v2)
40  {
41  return v1 == v2;
42  }
43 };
44 
45 template <typename T>
46 struct equals<T *, void>
47 {
48  inline static bool apply(const T * v1, const T * v2)
49  {
50  return v1 == v2;
51  }
52 };
53 
54 template <typename Tuple, size_t I, size_t N>
55 struct tuple_equals
56 {
57  inline static bool apply(Tuple const& t1, Tuple const& t2)
58  {
59  typedef typename boost::tuples::element<I, Tuple>::type T;
60 
61  return equals<T>::apply(boost::get<I>(t1), boost::get<I>(t2))
62  && tuple_equals<Tuple, I+1, N>::apply(t1, t2);
63  }
64 };
65 
66 template <typename Tuple, size_t I>
67 struct tuple_equals<Tuple, I, I>
68 {
69  inline static bool apply(Tuple const&, Tuple const&)
70  {
71  return true;
72  }
73 };
74 
75 // TODO: Consider this: Since equal_to<> is using geometry::equals() it's possible that
76 // two compared Indexables are not exactly the same! They will be spatially equal
77 // but not strictly equal. Consider 2 Segments with reversed order of points.
78 // Therefore it's possible that during the Value removal different value will be
79 // removed than the one that was passed.
80 
91 template <typename Value,
92  bool IsIndexable = is_indexable<Value>::value>
93 struct equal_to
94 {
96  typedef bool result_type;
97 
105  inline bool operator()(Value const& l, Value const& r) const
106  {
107  return detail::equals<Value>::apply(l ,r);
108  }
109 };
110 
120 template <typename T1, typename T2>
121 struct equal_to<std::pair<T1, T2>, false>
122 {
124  typedef bool result_type;
125 
133  inline bool operator()(std::pair<T1, T2> const& l, std::pair<T1, T2> const& r) const
134  {
135  return detail::equals<T1>::apply(l.first, r.first)
136  && detail::equals<T2>::apply(l.second, r.second);
137  }
138 };
139 
146 template <typename T0, typename T1, typename T2, typename T3, typename T4,
147  typename T5, typename T6, typename T7, typename T8, typename T9>
148 struct equal_to<boost::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>, false>
149 {
150  typedef boost::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> value_type;
151 
153  typedef bool result_type;
154 
162  inline bool operator()(value_type const& l, value_type const& r) const
163  {
164  return detail::tuple_equals<
165  value_type, 0, boost::tuples::length<value_type>::value
166  >::apply(l ,r);
167  }
168 };
169 
170 }}}} // namespace boost::geometry::index::detail
171 
172 #if !defined(BOOST_NO_CXX11_HDR_TUPLE) && !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
173 
174 #include <tuple>
175 
176 namespace boost { namespace geometry { namespace index { namespace detail {
177 
178 template <typename Tuple, size_t I, size_t N>
179 struct std_tuple_equals
180 {
181  inline static bool apply(Tuple const& t1, Tuple const& t2)
182  {
183  typedef typename std::tuple_element<I, Tuple>::type T;
184 
185  return equals<T>::apply(std::get<I>(t1), std::get<I>(t2))
186  && std_tuple_equals<Tuple, I+1, N>::apply(t1, t2);
187  }
188 };
189 
190 template <typename Tuple, size_t I>
191 struct std_tuple_equals<Tuple, I, I>
192 {
193  inline static bool apply(Tuple const&, Tuple const&)
194  {
195  return true;
196  }
197 };
198 
206 template <typename ...Args>
207 struct equal_to<std::tuple<Args...>, false>
208 {
209  typedef std::tuple<Args...> value_type;
210 
212  typedef bool result_type;
213 
221  bool operator()(value_type const& l, value_type const& r) const
222  {
223  return detail::std_tuple_equals<
224  value_type, 0, std::tuple_size<value_type>::value
225  >::apply(l ,r);
226  }
227 };
228 
229 }}}} // namespace boost::geometry::index::detail
230 
231 #endif // !defined(BOOST_NO_CXX11_HDR_TUPLE) && !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
232 
233 namespace boost { namespace geometry { namespace index {
234 
245 template <typename Value>
246 struct equal_to
247  : detail::equal_to<Value>
248 {
251 
259  inline bool operator()(Value const& l, Value const& r) const
260  {
262  }
263 };
264 
265 }}} // namespace boost::geometry::index
266 
267 #endif // BOOST_GEOMETRY_INDEX_EQUAL_TO_HPP
bool operator()(Value const &l, Value const &r) const
Compare values. If Value is a Geometry geometry::equals() function is used.
Definition: equal_to.hpp:105
detail::equal_to< Value >::result_type result_type
The type of result returned by function object.
Definition: equal_to.hpp:250
bool result_type
The type of result returned by function object.
Definition: equal_to.hpp:153
The function object comparing Values.
Definition: equal_to.hpp:93
bool operator()(value_type const &l, value_type const &r) const
Compare values. If tuple<> Value member is a Geometry geometry::equals() function is used...
Definition: equal_to.hpp:221
bool operator()(value_type const &l, value_type const &r) const
Compare values. If tuple<> Value member is a Geometry geometry::equals() function is used...
Definition: equal_to.hpp:162
The function object comparing Values.
Definition: equal_to.hpp:246
bool result_type
The type of result returned by function object.
Definition: equal_to.hpp:124
bool operator()(Value const &l, Value const &r) const
Compare Values.
Definition: equal_to.hpp:259
bool operator()(std::pair< T1, T2 > const &l, std::pair< T1, T2 > const &r) const
Compare values. If pair<> Value member is a Geometry geometry::equals() function is used...
Definition: equal_to.hpp:133
bool result_type
The type of result returned by function object.
Definition: equal_to.hpp:96
bool result_type
The type of result returned by function object.
Definition: equal_to.hpp:212