1// Boost.Geometry
2// Unit Test
3
4// Copyright (c) 2014-2021 Oracle and/or its affiliates.
5
6// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
7
8// Licensed under the Boost Software License version 1.0.
9// http://www.boost.org/users/license.html
10
11#include <geometry_test_common.hpp>
12
13#include <iterator>
14#include <vector>
15
16#include <boost/range/iterator_range.hpp>
17
18#include <boost/geometry/util/range.hpp>
19
20namespace bgt {
21
22struct NonCopyable
23{
24 NonCopyable(int ii = 0) : i(ii) {}
25 NonCopyable(NonCopyable && ii) : i(ii.i) {}
26 NonCopyable & operator=(NonCopyable && ii) { i = ii.i; return *this; }
27 bool operator==(NonCopyable const& ii) const { return i == ii.i; }
28 int i;
29 NonCopyable(NonCopyable const& ii) = delete;
30 NonCopyable & operator=(NonCopyable const& ii) = delete;
31};
32
33struct CopyableAndMovable
34{
35 CopyableAndMovable(int ii = 0) : i(ii) {}
36 CopyableAndMovable(CopyableAndMovable const& ii) : i(ii.i) {}
37 CopyableAndMovable & operator=(CopyableAndMovable const& ii) { i = ii.i; return *this; }
38 bool operator==(CopyableAndMovable const& ii) const { return i == ii.i; }
39 int i;
40 CopyableAndMovable(CopyableAndMovable && ii) : i(std::move(ii.i)) {}
41 CopyableAndMovable & operator=(CopyableAndMovable && ii) { i = std::move(ii.i); return *this; }
42};
43
44template <typename Container>
45struct proxy
46{
47 using iterator = typename boost::range_iterator<Container>::type;
48 using const_iterator = typename boost::range_iterator<Container const>::type;
49
50 explicit proxy(Container & container) : m_ptr(&container) {}
51 template <typename T>
52 void push_back(T&& v) { m_ptr->push_back(std::forward<T>(v)); }
53 template <typename ...Ts>
54 void emplace_back(Ts&&... vs) { m_ptr->emplace_back(std::forward<Ts>(vs)...); }
55 void clear() { m_ptr->clear(); }
56 void resize(size_t n) { m_ptr->resize(n); }
57
58 iterator begin() { return m_ptr->begin(); }
59 const_iterator begin() const { return m_ptr->begin(); }
60 iterator end() { return m_ptr->end(); }
61 const_iterator end() const { return m_ptr->end(); }
62
63private:
64 Container * m_ptr;
65};
66
67template <typename Container>
68bgt::proxy<Container> make_proxy(Container & container)
69{
70 return bgt::proxy<Container>(container);
71}
72
73} // namespace bgt
74
75namespace bgr = bg::range;
76
77template <typename T>
78void fill(std::vector<T> & v, int n)
79{
80 for (int i = 0; i < n; ++i)
81 {
82 bgr::push_back(v, i);
83 }
84}
85
86template <typename T>
87void test_push_emplace(std::vector<T> & v)
88{
89 bgr::push_back(v, 0);
90 bgr::push_back(bgt::make_proxy(v), 1);
91 bgr::emplace_back(v, 2);
92 bgr::emplace_back(bgt::make_proxy(v), 3);
93
94 typename std::vector<T>::value_type val = 4;
95 bgr::push_back(v, std::move(val));
96 val = 5;
97 bgr::push_back(bgt::make_proxy(v), std::move(val));
98 val = 6;
99 bgr::emplace_back(v, std::move(val));
100 val = 7;
101 bgr::emplace_back(bgt::make_proxy(v), std::move(val));
102
103 for (int i = (int)v.size(); i < 20; ++i)
104 {
105 bgr::push_back(v, i);
106 }
107}
108
109template <typename T>
110void test_at_front_back(std::vector<T> const& v)
111{
112 BOOST_CHECK(bgr::at(v, 1) == 1);
113 BOOST_CHECK(bgr::at(bgt::make_proxy(v), 2) == 2);
114 BOOST_CHECK(bgr::at(std::make_pair(v.begin(), v.end()), 3) == 3);
115
116 BOOST_CHECK(bgr::front(v) == 0);
117 BOOST_CHECK(bgr::front(bgt::make_proxy(v)) == 0);
118 BOOST_CHECK(bgr::front(std::make_pair(v.begin(), v.end())) == 0);
119
120 BOOST_CHECK(bgr::back(v) == 19);
121 BOOST_CHECK(bgr::back(bgt::make_proxy(v)) == 19);
122 BOOST_CHECK(bgr::back(std::make_pair(v.begin(), v.end())) == 19);
123}
124
125template <typename T>
126void test_at_front_back(std::vector<T> & v)
127{
128 bgr::at(v, 1) = 101;
129 bgr::at(bgt::make_proxy(v), 2) = 102;
130 bgr::at(std::make_pair(v.begin(), v.end()), 3) = 103;
131
132 BOOST_CHECK(bgr::at(v, 1) == 101);
133 BOOST_CHECK(bgr::at(bgt::make_proxy(v), 2) == 102);
134 BOOST_CHECK(bgr::at(std::make_pair(v.begin(), v.end()), 3) == 103);
135
136 bgr::at(v, 1) = 1;
137 bgr::at(bgt::make_proxy(v), 2) = 2;
138 bgr::at(std::make_pair(v.begin(), v.end()), 3) = 3;
139
140 bgr::front(v) = 100;
141 BOOST_CHECK(bgr::front(v) == 100);
142 bgr::front(bgt::make_proxy(v)) = 200;
143 BOOST_CHECK(bgr::front(v) == 200);
144 bgr::front(std::make_pair(v.begin(), v.end())) = 0;
145 BOOST_CHECK(bgr::front(v) == 0);
146
147 bgr::back(v) = 119;
148 BOOST_CHECK(bgr::back(v) == 119);
149 bgr::back(bgt::make_proxy(v)) = 219;
150 BOOST_CHECK(bgr::back(v) == 219);
151 bgr::back(std::make_pair(v.begin(), v.end())) = 19;
152 BOOST_CHECK(bgr::back(v) == 19);
153}
154
155template <typename T>
156void test_clear(std::vector<T> & v)
157{
158 std::vector<T> w;
159 std::copy(v.begin(), v.end(), bgr::back_inserter(w));
160 BOOST_CHECK(w.size() == 20 && std::equal(v.begin(), v.end(), w.begin()));
161 bgr::clear(w);
162 BOOST_CHECK(w.size() == 0);
163 w = v;
164 BOOST_CHECK(w.size() == 20);
165 bgr::clear(bgt::make_proxy(w));
166 BOOST_CHECK(w.size() == 0);
167}
168
169void test_clear(std::vector<bgt::NonCopyable> & )
170{}
171
172template <typename T>
173void test_resize_pop(std::vector<T> & v)
174{
175 BOOST_CHECK(boost::size(v) == 20); // [0,19]
176 bgr::resize(v, 18);
177 BOOST_CHECK(boost::size(v) == 18); // [0,17]
178 bgr::resize(bgt::make_proxy(v), 16);
179 BOOST_CHECK(boost::size(v) == 16); // [0,15]
180 BOOST_CHECK(bgr::back(v) == 15);
181
182 bgr::pop_back(v);
183 BOOST_CHECK(boost::size(v) == 15); // [0,14]
184 bgr::pop_back(bgt::make_proxy(v));
185 BOOST_CHECK(boost::size(v) == 14); // [0,13]
186 BOOST_CHECK(bgr::back(v) == 13);
187}
188
189template <typename T, typename Begin, typename End>
190void test_erase(std::vector<T> & v, Begin begin, End end)
191{
192 typename std::vector<T>::iterator
193 it = bgr::erase(v, end(v) - 1);
194 BOOST_CHECK(boost::size(v) == 13); // [0,12]
195 BOOST_CHECK(bgr::back(v) == 12);
196 BOOST_CHECK(it == end(v));
197
198 it = bgr::erase(v, end(v) - 3, end(v));
199 BOOST_CHECK(boost::size(v) == 10); // [0,9]
200 BOOST_CHECK(bgr::back(v) == 9);
201 BOOST_CHECK(it == end(v));
202
203 it = bgr::erase(bgt::make_proxy(v), begin(v) + 2);
204 BOOST_CHECK(boost::size(v) == 9); // {0,1,3..9}
205 BOOST_CHECK(bgr::at(v, 1) == 1);
206 BOOST_CHECK(bgr::at(v, 2) == 3);
207 BOOST_CHECK(bgr::back(v) == 9);
208 BOOST_CHECK(it == bgr::pos(v, 2));
209
210 it = bgr::erase(bgt::make_proxy(v), begin(v) + 2, begin(v) + 2);
211 BOOST_CHECK(boost::size(v) == 9); // {0,1,3..9}
212 BOOST_CHECK(bgr::at(v, 1) == 1);
213 BOOST_CHECK(bgr::at(v, 2) == 3);
214 BOOST_CHECK(bgr::back(v) == 9);
215 BOOST_CHECK(it == bgr::pos(v, 2));
216
217 it = bgr::erase(v, begin(v) + 2, begin(v) + 5);
218 BOOST_CHECK(boost::size(v) == 6); // {0,1,6..9}
219 BOOST_CHECK(bgr::at(v, 1) == 1);
220 BOOST_CHECK(bgr::at(v, 2) == 6);
221 BOOST_CHECK(bgr::back(v) == 9);
222 BOOST_CHECK(it == bgr::pos(v, 2));
223
224 it = bgr::erase(v, begin(v));
225 BOOST_CHECK(boost::size(v) == 5); // {1,6..9}
226 BOOST_CHECK(bgr::at(v, 0) == 1);
227 BOOST_CHECK(bgr::at(v, 1) == 6);
228 BOOST_CHECK(bgr::back(v) == 9);
229 BOOST_CHECK(it == bgr::pos(v, 0));
230
231 it = bgr::erase(v, begin(v), begin(v) + 3);
232 BOOST_CHECK(boost::size(v) == 2); // {8,9}
233 BOOST_CHECK(bgr::at(v, 0) == 8);
234 BOOST_CHECK(bgr::at(v, 1) == 9);
235 BOOST_CHECK(bgr::back(v) == 9);
236 BOOST_CHECK(it == bgr::pos(v, 0));
237
238 it = bgr::erase(v, begin(v), end(v));
239 BOOST_CHECK(boost::size(v) == 0);
240 BOOST_CHECK(it == end(v));
241}
242
243template <typename T, typename Begin, typename End>
244void test_erase(std::vector<bgt::NonCopyable> & , Begin , End )
245{}
246
247template <typename T>
248void test_all()
249{
250 std::vector<T> v;
251
252 test_push_emplace(v);
253
254 BOOST_CHECK(boost::size(v) == 20);
255
256 test_at_front_back(v);
257 test_at_front_back(const_cast<std::vector<T> const&>(v));
258
259 test_clear(v);
260
261 test_resize_pop(v);
262
263 int n = (int)v.size();
264
265 test_erase(v, [](auto & rng) { return boost::begin(rng); },
266 [](auto & rng) { return boost::end(rng); });
267
268 bgr::clear(v);
269 fill(v, n);
270
271 test_erase(v, [](auto & rng) { return boost::const_begin(rng); },
272 [](auto & rng) { return boost::const_end(rng); });
273}
274
275void test_detail()
276{
277 int arr[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
278 std::move(first: arr + 1, last: arr + 10, result: arr);
279 BOOST_CHECK(arr[0] == 1);
280
281 std::vector<int> v(10, 0);
282 std::move(first: v.begin() + 1, last: v.begin() + 10, result: v.begin());
283 BOOST_CHECK(boost::size(v) == 10);
284 bgr::erase(rng&: v, it: v.begin() + 1);
285 BOOST_CHECK(boost::size(v) == 9);
286}
287
288template <class Iterator>
289void test_pointers()
290{
291 int arr[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
292
293 boost::iterator_range<Iterator> r1(arr, arr + 10);
294 std::pair<Iterator, Iterator> r2(arr, arr + 10);
295
296 BOOST_CHECK(bgr::front(r1) == 0);
297 BOOST_CHECK(bgr::front(r2) == 0);
298 BOOST_CHECK(bgr::back(r1) == 9);
299 BOOST_CHECK(bgr::back(r2) == 9);
300 BOOST_CHECK(bgr::at(r1, 5) == 5);
301 BOOST_CHECK(bgr::at(r2, 5) == 5);
302}
303
304int test_main(int, char* [])
305{
306 test_all<int>();
307 test_all<bgt::CopyableAndMovable>();
308 test_all<bgt::NonCopyable>();
309
310 test_detail();
311
312 test_pointers<int*>();
313 test_pointers<int const*>();
314
315 return 0;
316}
317

source code of boost/libs/geometry/test/util/range.cpp