Chris@16
|
1 // -- algorithm.hpp -- Boost Lambda Library -----------------------------------
|
Chris@16
|
2 // Copyright (C) 2002 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
|
Chris@16
|
3 // Copyright (C) 2002 Gary Powell (gwpowell@hotmail.com)
|
Chris@16
|
4 //
|
Chris@16
|
5 // Distributed under the Boost Software License, Version 1.0. (See
|
Chris@16
|
6 // accompanying file LICENSE_1_0.txt or copy at
|
Chris@16
|
7 // http://www.boost.org/LICENSE_1_0.txt)
|
Chris@16
|
8 //
|
Chris@16
|
9 // For more information, see http://www.boost.org
|
Chris@16
|
10
|
Chris@16
|
11 #ifndef BOOST_LAMBDA_ALGORITHM_HPP
|
Chris@16
|
12 #define BOOST_LAMBDA_ALGORITHM_HPP
|
Chris@16
|
13
|
Chris@16
|
14 #include "boost/lambda/core.hpp"
|
Chris@16
|
15
|
Chris@16
|
16 #include <algorithm>
|
Chris@16
|
17 #include <iterator> // for iterator_traits
|
Chris@16
|
18 #include <utility> // for std::pair
|
Chris@16
|
19
|
Chris@16
|
20 namespace boost {
|
Chris@16
|
21 namespace lambda {
|
Chris@16
|
22
|
Chris@16
|
23 namespace ll {
|
Chris@16
|
24
|
Chris@16
|
25 // for_each ---------------------------------
|
Chris@16
|
26
|
Chris@16
|
27 struct for_each {
|
Chris@16
|
28
|
Chris@16
|
29 template <class Args>
|
Chris@16
|
30 struct sig {
|
Chris@16
|
31 typedef typename boost::remove_const<
|
Chris@16
|
32 typename boost::tuples::element<3, Args>::type
|
Chris@16
|
33 >::type type;
|
Chris@16
|
34 };
|
Chris@16
|
35
|
Chris@16
|
36 template <class A, class C>
|
Chris@16
|
37 C
|
Chris@16
|
38 operator()(A a, A b, C c) const
|
Chris@16
|
39 { return ::std::for_each(a, b, c); }
|
Chris@16
|
40 };
|
Chris@16
|
41
|
Chris@16
|
42 // find ---------------------------------
|
Chris@16
|
43
|
Chris@16
|
44 struct find {
|
Chris@16
|
45
|
Chris@16
|
46 template <class Args>
|
Chris@16
|
47 struct sig {
|
Chris@16
|
48 typedef typename boost::remove_const<
|
Chris@16
|
49 typename boost::tuples::element<1, Args>::type
|
Chris@16
|
50 >::type type;
|
Chris@16
|
51 };
|
Chris@16
|
52
|
Chris@16
|
53 template <class A, class C>
|
Chris@16
|
54 A
|
Chris@16
|
55 operator()(A a, A b, const C& c) const
|
Chris@16
|
56 { return ::std::find(a, b, c); }
|
Chris@16
|
57 };
|
Chris@16
|
58
|
Chris@16
|
59
|
Chris@16
|
60 // find_if ---------------------------------
|
Chris@16
|
61
|
Chris@16
|
62 struct find_if {
|
Chris@16
|
63
|
Chris@16
|
64 template <class Args>
|
Chris@16
|
65 struct sig {
|
Chris@16
|
66 typedef typename boost::remove_const<
|
Chris@16
|
67 typename boost::tuples::element<1, Args>::type
|
Chris@16
|
68 >::type type;
|
Chris@16
|
69 };
|
Chris@16
|
70
|
Chris@16
|
71 template <class A, class C>
|
Chris@16
|
72 A
|
Chris@16
|
73 operator()(A a, A b, C c) const
|
Chris@16
|
74 { return ::std::find_if(a, b, c); }
|
Chris@16
|
75 };
|
Chris@16
|
76
|
Chris@16
|
77 // find_end ---------------------------------
|
Chris@16
|
78
|
Chris@16
|
79 struct find_end {
|
Chris@16
|
80
|
Chris@16
|
81 template <class Args>
|
Chris@16
|
82 struct sig {
|
Chris@16
|
83 typedef typename boost::remove_const<
|
Chris@16
|
84 typename boost::tuples::element<1, Args>::type
|
Chris@16
|
85 >::type type;
|
Chris@16
|
86 };
|
Chris@16
|
87
|
Chris@16
|
88 template <class A, class C>
|
Chris@16
|
89 A
|
Chris@16
|
90 operator()(A a, A b, C c, C d) const
|
Chris@16
|
91 { return ::std::find_end(a, b, c, d); }
|
Chris@16
|
92
|
Chris@16
|
93 template <class A, class C, class E>
|
Chris@16
|
94 A
|
Chris@16
|
95 operator()(A a, A b, C c, C d, E e) const
|
Chris@16
|
96 { return ::std::find_end(a, b, c, d, e); }
|
Chris@16
|
97
|
Chris@16
|
98 };
|
Chris@16
|
99
|
Chris@16
|
100 // find_first_of ---------------------------------
|
Chris@16
|
101
|
Chris@16
|
102 struct find_first_of {
|
Chris@16
|
103
|
Chris@16
|
104 template <class Args>
|
Chris@16
|
105 struct sig {
|
Chris@16
|
106 typedef typename boost::remove_const<
|
Chris@16
|
107 typename boost::tuples::element<1, Args>::type
|
Chris@16
|
108 >::type type;
|
Chris@16
|
109 };
|
Chris@16
|
110
|
Chris@16
|
111 template <class A, class C>
|
Chris@16
|
112 A
|
Chris@16
|
113 operator()(A a, A b, C c, C d) const
|
Chris@16
|
114 { return ::std::find_first_of(a, b, c, d); }
|
Chris@16
|
115
|
Chris@16
|
116 template <class A, class C, class E>
|
Chris@16
|
117 A
|
Chris@16
|
118 operator()(A a, A b, C c, C d, E e) const
|
Chris@16
|
119 { return ::std::find_first_of(a, b, c, d, e); }
|
Chris@16
|
120
|
Chris@16
|
121 };
|
Chris@16
|
122
|
Chris@16
|
123 // adjacent_find ---------------------------------
|
Chris@16
|
124
|
Chris@16
|
125 struct adjacent_find {
|
Chris@16
|
126
|
Chris@16
|
127 template <class Args>
|
Chris@16
|
128 struct sig {
|
Chris@16
|
129 typedef typename boost::remove_const<
|
Chris@16
|
130 typename boost::tuples::element<1, Args>::type
|
Chris@16
|
131 >::type type;
|
Chris@16
|
132 };
|
Chris@16
|
133
|
Chris@16
|
134 template <class A>
|
Chris@16
|
135 A
|
Chris@16
|
136 operator()(A a, A b) const
|
Chris@16
|
137 { return ::std::adjacent_find(a, b); }
|
Chris@16
|
138
|
Chris@16
|
139 template <class A, class C>
|
Chris@16
|
140 A
|
Chris@16
|
141 operator()(A a, A b, C c) const
|
Chris@16
|
142 { return ::std::adjacent_find(a, b, c); }
|
Chris@16
|
143
|
Chris@16
|
144 };
|
Chris@16
|
145
|
Chris@16
|
146 // count ---------------------------------
|
Chris@16
|
147
|
Chris@16
|
148 struct count {
|
Chris@16
|
149
|
Chris@16
|
150 template <class Args>
|
Chris@16
|
151 struct sig {
|
Chris@16
|
152 typedef typename ::std::iterator_traits<
|
Chris@16
|
153 typename boost::remove_const<
|
Chris@16
|
154 typename boost::tuples::element<1, Args>::type
|
Chris@16
|
155 >::type
|
Chris@16
|
156 >::difference_type type;
|
Chris@16
|
157 };
|
Chris@16
|
158
|
Chris@16
|
159 template <class A, class C >
|
Chris@16
|
160 typename ::std::iterator_traits<A>::difference_type
|
Chris@16
|
161 operator()(A a, A b, const C& c) const
|
Chris@16
|
162 { return ::std::count(a, b, c); }
|
Chris@16
|
163 };
|
Chris@16
|
164
|
Chris@16
|
165 // count_if ---------------------------------
|
Chris@16
|
166
|
Chris@16
|
167 struct count_if {
|
Chris@16
|
168
|
Chris@16
|
169 template <class Args>
|
Chris@16
|
170 struct sig {
|
Chris@16
|
171 typedef typename ::std::iterator_traits<
|
Chris@16
|
172 typename boost::remove_const<
|
Chris@16
|
173 typename boost::tuples::element<1, Args>::type
|
Chris@16
|
174 >::type
|
Chris@16
|
175 >::difference_type type;
|
Chris@16
|
176 };
|
Chris@16
|
177
|
Chris@16
|
178 template <class A, class C >
|
Chris@16
|
179 typename ::std::iterator_traits<A>::difference_type
|
Chris@16
|
180 operator()(A a, A b, C c) const
|
Chris@16
|
181 { return ::std::count_if(a, b, c); }
|
Chris@16
|
182 };
|
Chris@16
|
183
|
Chris@16
|
184
|
Chris@16
|
185 // mismatch ---------------------------------
|
Chris@16
|
186
|
Chris@16
|
187 struct mismatch {
|
Chris@16
|
188
|
Chris@16
|
189 template <class Args>
|
Chris@16
|
190 struct sig {
|
Chris@16
|
191 typedef typename boost::remove_const<
|
Chris@16
|
192 typename boost::tuples::element<1, Args>::type
|
Chris@16
|
193 >::type element1_type;
|
Chris@16
|
194
|
Chris@16
|
195 typedef typename boost::remove_const<
|
Chris@16
|
196 typename boost::tuples::element<3, Args>::type
|
Chris@16
|
197 >::type element2_type;
|
Chris@16
|
198
|
Chris@16
|
199 typedef ::std::pair< element1_type, element2_type > type;
|
Chris@16
|
200 };
|
Chris@16
|
201
|
Chris@16
|
202 template <class A, class C >
|
Chris@16
|
203 ::std::pair<A,C>
|
Chris@16
|
204 operator()(A a, A b, C c) const
|
Chris@16
|
205 { return ::std::mismatch(a, b, c); }
|
Chris@16
|
206
|
Chris@16
|
207 template <class A, class C, class D>
|
Chris@16
|
208 ::std::pair<A,C>
|
Chris@16
|
209 operator()(A a, A b, C c, D d) const
|
Chris@16
|
210 { return ::std::mismatch(a, b, c, d); }
|
Chris@16
|
211
|
Chris@16
|
212 };
|
Chris@16
|
213
|
Chris@16
|
214 // equal ---------------------------------
|
Chris@16
|
215
|
Chris@16
|
216 struct equal {
|
Chris@16
|
217
|
Chris@16
|
218 template <class Args>
|
Chris@16
|
219 struct sig {
|
Chris@16
|
220 typedef bool type;
|
Chris@16
|
221 };
|
Chris@16
|
222
|
Chris@16
|
223 template <class A, class C >
|
Chris@16
|
224 bool
|
Chris@16
|
225 operator()(A a, A b, C c) const
|
Chris@16
|
226 { return ::std::equal(a, b, c); }
|
Chris@16
|
227
|
Chris@16
|
228 template <class A, class C, class D>
|
Chris@16
|
229 bool
|
Chris@16
|
230 operator()(A a, A b, C c, D d) const
|
Chris@16
|
231 { return ::std::equal(a, b, c, d); }
|
Chris@16
|
232
|
Chris@16
|
233 };
|
Chris@16
|
234
|
Chris@16
|
235 // search --------------------------------
|
Chris@16
|
236
|
Chris@16
|
237 struct search {
|
Chris@16
|
238
|
Chris@16
|
239 template <class Args>
|
Chris@16
|
240 struct sig {
|
Chris@16
|
241 typedef typename boost::remove_const<
|
Chris@16
|
242 typename boost::tuples::element<1, Args>::type
|
Chris@16
|
243 >::type type;
|
Chris@16
|
244 };
|
Chris@16
|
245
|
Chris@16
|
246 template <class A, class C>
|
Chris@16
|
247 A
|
Chris@16
|
248 operator()(A a, A b, C c, C d) const
|
Chris@16
|
249 { return std::search(a, b, c, d);}
|
Chris@16
|
250
|
Chris@16
|
251 template <class A, class C, class E>
|
Chris@16
|
252 A
|
Chris@16
|
253 operator()(A a, A b, C c, C d, E e) const
|
Chris@16
|
254 { return std::search(a, b, c, d, e);}
|
Chris@16
|
255
|
Chris@16
|
256 };
|
Chris@16
|
257
|
Chris@16
|
258 // copy ---------------------------------
|
Chris@16
|
259
|
Chris@16
|
260 struct copy {
|
Chris@16
|
261
|
Chris@16
|
262 template <class Args>
|
Chris@16
|
263 struct sig {
|
Chris@16
|
264 typedef typename boost::remove_const<
|
Chris@16
|
265 typename boost::tuples::element<3, Args>::type
|
Chris@16
|
266 >::type type;
|
Chris@16
|
267 };
|
Chris@16
|
268
|
Chris@16
|
269 template <class A, class C>
|
Chris@16
|
270 C
|
Chris@16
|
271 operator()(A a, A b, C c) const
|
Chris@16
|
272 { return ::std::copy(a, b, c); }
|
Chris@16
|
273
|
Chris@16
|
274 };
|
Chris@16
|
275
|
Chris@16
|
276 // copy_backward ---------------------------------
|
Chris@16
|
277
|
Chris@16
|
278 struct copy_backward {
|
Chris@16
|
279
|
Chris@16
|
280 template <class Args>
|
Chris@16
|
281 struct sig {
|
Chris@16
|
282 typedef typename boost::remove_const<
|
Chris@16
|
283 typename boost::tuples::element<3, Args>::type
|
Chris@16
|
284 >::type type;
|
Chris@16
|
285 };
|
Chris@16
|
286
|
Chris@16
|
287 template <class A, class C>
|
Chris@16
|
288 C
|
Chris@16
|
289 operator()(A a, A b, C c) const
|
Chris@16
|
290 { return ::std::copy_backward(a, b, c); }
|
Chris@16
|
291
|
Chris@16
|
292 };
|
Chris@16
|
293
|
Chris@16
|
294 // swap ---------------------------------
|
Chris@16
|
295
|
Chris@16
|
296 struct swap {
|
Chris@16
|
297
|
Chris@16
|
298 template <class Args>
|
Chris@16
|
299 struct sig {
|
Chris@16
|
300 typedef void type;
|
Chris@16
|
301 };
|
Chris@16
|
302
|
Chris@16
|
303 template <class A>
|
Chris@16
|
304 void
|
Chris@16
|
305 operator()(A a, A b) const
|
Chris@16
|
306 { ::std::swap(a, b); }
|
Chris@16
|
307
|
Chris@16
|
308 };
|
Chris@16
|
309
|
Chris@16
|
310 // swap_ranges ---------------------------------
|
Chris@16
|
311
|
Chris@16
|
312 struct swap_ranges {
|
Chris@16
|
313
|
Chris@16
|
314 template <class Args>
|
Chris@16
|
315 struct sig {
|
Chris@16
|
316 typedef typename boost::remove_const<
|
Chris@16
|
317 typename boost::tuples::element<3, Args>::type
|
Chris@16
|
318 >::type type;
|
Chris@16
|
319 };
|
Chris@16
|
320
|
Chris@16
|
321 template <class A, class C>
|
Chris@16
|
322 C
|
Chris@16
|
323 operator()(A a, A b, C c) const
|
Chris@16
|
324 { return ::std::swap_ranges(a, b, c); }
|
Chris@16
|
325
|
Chris@16
|
326 };
|
Chris@16
|
327
|
Chris@16
|
328 // iter_swap ---------------------------------
|
Chris@16
|
329
|
Chris@16
|
330 struct iter_swap {
|
Chris@16
|
331
|
Chris@16
|
332 template <class Args>
|
Chris@16
|
333 struct sig {
|
Chris@16
|
334 typedef void type;
|
Chris@16
|
335 };
|
Chris@16
|
336
|
Chris@16
|
337 template <class A>
|
Chris@16
|
338 void
|
Chris@16
|
339 operator()(A a, A b) const
|
Chris@16
|
340 { ::std::iter_swap(a, b); }
|
Chris@16
|
341
|
Chris@16
|
342 };
|
Chris@16
|
343
|
Chris@16
|
344
|
Chris@16
|
345 // transform --------------------------------
|
Chris@16
|
346
|
Chris@16
|
347 struct transform {
|
Chris@16
|
348
|
Chris@16
|
349 template <class Args>
|
Chris@16
|
350 struct sig {
|
Chris@16
|
351 typedef typename boost::remove_const<
|
Chris@16
|
352 typename boost::tuples::element<
|
Chris@16
|
353 boost::tuples::length<Args>::value - 2,
|
Chris@16
|
354 Args
|
Chris@16
|
355 >::type
|
Chris@16
|
356 >::type type;
|
Chris@16
|
357 };
|
Chris@16
|
358
|
Chris@16
|
359 template <class A, class C, class D>
|
Chris@16
|
360 C
|
Chris@16
|
361 operator()(A a, A b, C c, D d) const
|
Chris@16
|
362 { return std::transform(a, b, c, d);}
|
Chris@16
|
363
|
Chris@16
|
364 template <class A, class C, class D, class E>
|
Chris@16
|
365 D
|
Chris@16
|
366 operator()(A a, A b, C c, D d, E e) const
|
Chris@16
|
367 { return std::transform(a, b, c, d, e);}
|
Chris@16
|
368
|
Chris@16
|
369 };
|
Chris@16
|
370
|
Chris@16
|
371 // replace ---------------------------------
|
Chris@16
|
372
|
Chris@16
|
373 struct replace {
|
Chris@16
|
374
|
Chris@16
|
375 template <class Args>
|
Chris@16
|
376 struct sig {
|
Chris@16
|
377 typedef void type;
|
Chris@16
|
378 };
|
Chris@16
|
379
|
Chris@16
|
380 template <class A, class C>
|
Chris@16
|
381 void
|
Chris@16
|
382 operator()(A a, A b, const C& c, const C& d) const
|
Chris@16
|
383 { ::std::replace(a, b, c, d); }
|
Chris@16
|
384
|
Chris@16
|
385 };
|
Chris@16
|
386
|
Chris@16
|
387 // replace_if ---------------------------------
|
Chris@16
|
388
|
Chris@16
|
389 struct replace_if {
|
Chris@16
|
390
|
Chris@16
|
391 template <class Args>
|
Chris@16
|
392 struct sig {
|
Chris@16
|
393 typedef void type;
|
Chris@16
|
394 };
|
Chris@16
|
395
|
Chris@16
|
396 template <class A, class C, class D>
|
Chris@16
|
397 void
|
Chris@16
|
398 operator()(A a, A b, C c, const D& d) const
|
Chris@16
|
399 { ::std::replace_if(a, b, c, d); }
|
Chris@16
|
400
|
Chris@16
|
401 };
|
Chris@16
|
402
|
Chris@16
|
403 // replace_copy ---------------------------------
|
Chris@16
|
404
|
Chris@16
|
405 struct replace_copy {
|
Chris@16
|
406
|
Chris@16
|
407 template <class Args>
|
Chris@16
|
408 struct sig {
|
Chris@16
|
409 typedef typename boost::remove_const<
|
Chris@16
|
410 typename boost::tuples::element<3, Args>::type
|
Chris@16
|
411 >::type type;
|
Chris@16
|
412 };
|
Chris@16
|
413
|
Chris@16
|
414 template <class A, class C, class D>
|
Chris@16
|
415 C
|
Chris@16
|
416 operator()(A a, A b, C c, const D& d, const D& e) const
|
Chris@16
|
417 { return ::std::replace_copy(a, b, c, d, e); }
|
Chris@16
|
418
|
Chris@16
|
419 };
|
Chris@16
|
420
|
Chris@16
|
421 // replace_copy_if ---------------------------------
|
Chris@16
|
422
|
Chris@16
|
423 struct replace_copy_if {
|
Chris@16
|
424
|
Chris@16
|
425 template <class Args>
|
Chris@16
|
426 struct sig {
|
Chris@16
|
427 typedef typename boost::remove_const<
|
Chris@16
|
428 typename boost::tuples::element<3, Args>::type
|
Chris@16
|
429 >::type type;
|
Chris@16
|
430 };
|
Chris@16
|
431
|
Chris@16
|
432 template <class A, class C, class D, class E>
|
Chris@16
|
433 C
|
Chris@16
|
434 operator()(A a, A b, C c, D d, const E& e) const
|
Chris@16
|
435 { return ::std::replace_copy_if(a, b, c, d, e); }
|
Chris@16
|
436
|
Chris@16
|
437 };
|
Chris@16
|
438
|
Chris@16
|
439 // fill ---------------------------------
|
Chris@16
|
440
|
Chris@16
|
441 struct fill {
|
Chris@16
|
442
|
Chris@16
|
443 template <class Args>
|
Chris@16
|
444 struct sig {
|
Chris@16
|
445 typedef void type;
|
Chris@16
|
446 };
|
Chris@16
|
447
|
Chris@16
|
448 template <class A, class C>
|
Chris@16
|
449 void
|
Chris@16
|
450 operator()(A a, A b, const C& c) const
|
Chris@16
|
451 { ::std::fill(a, b, c); }
|
Chris@16
|
452
|
Chris@16
|
453 };
|
Chris@16
|
454
|
Chris@16
|
455 // fill_n ---------------------------------
|
Chris@16
|
456
|
Chris@16
|
457 struct fill_n {
|
Chris@16
|
458
|
Chris@16
|
459 template <class Args>
|
Chris@16
|
460 struct sig {
|
Chris@16
|
461 typedef void type;
|
Chris@16
|
462 };
|
Chris@16
|
463
|
Chris@16
|
464 template <class A, class B, class C>
|
Chris@16
|
465 void
|
Chris@16
|
466 operator()(A a, B b, const C& c) const
|
Chris@16
|
467 { ::std::fill_n(a, b, c); }
|
Chris@16
|
468
|
Chris@16
|
469 };
|
Chris@16
|
470
|
Chris@16
|
471 // generate ---------------------------------
|
Chris@16
|
472
|
Chris@16
|
473 struct generate {
|
Chris@16
|
474
|
Chris@16
|
475 template <class Args>
|
Chris@16
|
476 struct sig {
|
Chris@16
|
477 typedef void type;
|
Chris@16
|
478 };
|
Chris@16
|
479
|
Chris@16
|
480 template <class A, class C>
|
Chris@16
|
481 void
|
Chris@16
|
482 operator()(A a, A b, C c) const
|
Chris@16
|
483 { ::std::generate(a, b, c); }
|
Chris@16
|
484
|
Chris@16
|
485 };
|
Chris@16
|
486
|
Chris@16
|
487 // generate_n ---------------------------------
|
Chris@16
|
488
|
Chris@16
|
489 struct generate_n {
|
Chris@16
|
490
|
Chris@16
|
491 template <class Args>
|
Chris@16
|
492 struct sig {
|
Chris@16
|
493 typedef void type;
|
Chris@16
|
494 };
|
Chris@16
|
495
|
Chris@16
|
496 template <class A, class B, class C>
|
Chris@16
|
497 void
|
Chris@16
|
498 operator()(A a, B b, C c) const
|
Chris@16
|
499 { ::std::generate_n(a, b, c); }
|
Chris@16
|
500
|
Chris@16
|
501 };
|
Chris@16
|
502
|
Chris@16
|
503 // remove ---------------------------------
|
Chris@16
|
504
|
Chris@16
|
505 struct remove {
|
Chris@16
|
506
|
Chris@16
|
507 template <class Args>
|
Chris@16
|
508 struct sig {
|
Chris@16
|
509 typedef typename boost::remove_const<
|
Chris@16
|
510 typename boost::tuples::element<1, Args>::type
|
Chris@16
|
511 >::type type;
|
Chris@16
|
512 };
|
Chris@16
|
513
|
Chris@16
|
514 template <class A, class C >
|
Chris@16
|
515 A
|
Chris@16
|
516 operator()(A a, A b, const C& c) const
|
Chris@16
|
517 { return ::std::remove(a, b, c); }
|
Chris@16
|
518 };
|
Chris@16
|
519
|
Chris@16
|
520 // remove_if ---------------------------------
|
Chris@16
|
521
|
Chris@16
|
522 struct remove_if {
|
Chris@16
|
523
|
Chris@16
|
524 template <class Args>
|
Chris@16
|
525 struct sig {
|
Chris@16
|
526 typedef typename boost::remove_const<
|
Chris@16
|
527 typename boost::tuples::element<1, Args>::type
|
Chris@16
|
528 >::type type;
|
Chris@16
|
529 };
|
Chris@16
|
530
|
Chris@16
|
531 template <class A, class C >
|
Chris@16
|
532 A
|
Chris@16
|
533 operator()(A a, A b, C c) const
|
Chris@16
|
534 { return ::std::remove_if(a, b, c); }
|
Chris@16
|
535 };
|
Chris@16
|
536
|
Chris@16
|
537 // remove_copy ---------------------------------
|
Chris@16
|
538
|
Chris@16
|
539 struct remove_copy {
|
Chris@16
|
540
|
Chris@16
|
541 template <class Args>
|
Chris@16
|
542 struct sig {
|
Chris@16
|
543 typedef typename boost::remove_const<
|
Chris@16
|
544 typename boost::tuples::element<3, Args>::type
|
Chris@16
|
545 >::type type;
|
Chris@16
|
546 };
|
Chris@16
|
547
|
Chris@16
|
548 template <class A, class C, class D >
|
Chris@16
|
549 C
|
Chris@16
|
550 operator()(A a, A b, C c, const D& d) const
|
Chris@16
|
551 { return ::std::remove_copy(a, b, c, d); }
|
Chris@16
|
552 };
|
Chris@16
|
553
|
Chris@16
|
554 // remove_copy_if ---------------------------------
|
Chris@16
|
555
|
Chris@16
|
556 struct remove_copy_if {
|
Chris@16
|
557
|
Chris@16
|
558 template <class Args>
|
Chris@16
|
559 struct sig {
|
Chris@16
|
560 typedef typename boost::remove_const<
|
Chris@16
|
561 typename boost::tuples::element<3, Args>::type
|
Chris@16
|
562 >::type type;
|
Chris@16
|
563 };
|
Chris@16
|
564
|
Chris@16
|
565 template <class A, class C, class D >
|
Chris@16
|
566 C
|
Chris@16
|
567 operator()(A a, A b, C c, D d) const
|
Chris@16
|
568 { return ::std::remove_copy_if(a, b, c, d); }
|
Chris@16
|
569 };
|
Chris@16
|
570
|
Chris@16
|
571 // unique ---------------------------------
|
Chris@16
|
572
|
Chris@16
|
573 struct unique {
|
Chris@16
|
574
|
Chris@16
|
575 template <class Args>
|
Chris@16
|
576 struct sig {
|
Chris@16
|
577 typedef typename boost::remove_const<
|
Chris@16
|
578 typename boost::tuples::element<1, Args>::type
|
Chris@16
|
579 >::type type;
|
Chris@16
|
580 };
|
Chris@16
|
581
|
Chris@16
|
582 template <class A>
|
Chris@16
|
583 A
|
Chris@16
|
584 operator()(A a, A b) const
|
Chris@16
|
585 { return ::std::unique(a, b); }
|
Chris@16
|
586
|
Chris@16
|
587 template <class A, class C>
|
Chris@16
|
588 A
|
Chris@16
|
589 operator()(A a, A b, C c) const
|
Chris@16
|
590 { return ::std::unique(a, b, c); }
|
Chris@16
|
591
|
Chris@16
|
592 };
|
Chris@16
|
593
|
Chris@16
|
594 // unique_copy ---------------------------------
|
Chris@16
|
595
|
Chris@16
|
596 struct unique_copy {
|
Chris@16
|
597
|
Chris@16
|
598 template <class Args>
|
Chris@16
|
599 struct sig {
|
Chris@16
|
600 typedef typename boost::remove_const<
|
Chris@16
|
601 typename boost::tuples::element<3, Args>::type
|
Chris@16
|
602 >::type type;
|
Chris@16
|
603 };
|
Chris@16
|
604
|
Chris@16
|
605 template <class A, class C >
|
Chris@16
|
606 C
|
Chris@16
|
607 operator()(A a, A b, C c) const
|
Chris@16
|
608 { return ::std::unique_copy(a, b, c); }
|
Chris@16
|
609
|
Chris@16
|
610 template <class A, class C, class D>
|
Chris@16
|
611 C
|
Chris@16
|
612 operator()(A a, A b, C c, D d) const
|
Chris@16
|
613 { return ::std::unique_copy(a, b, c, d); }
|
Chris@16
|
614
|
Chris@16
|
615 };
|
Chris@16
|
616
|
Chris@16
|
617 // reverse ---------------------------------
|
Chris@16
|
618
|
Chris@16
|
619 struct reverse {
|
Chris@16
|
620
|
Chris@16
|
621 template <class Args>
|
Chris@16
|
622 struct sig {
|
Chris@16
|
623 typedef void type;
|
Chris@16
|
624 };
|
Chris@16
|
625
|
Chris@16
|
626 template <class A>
|
Chris@16
|
627 void
|
Chris@16
|
628 operator()(A a, A b) const
|
Chris@16
|
629 { ::std::reverse(a, b); }
|
Chris@16
|
630
|
Chris@16
|
631 };
|
Chris@16
|
632
|
Chris@16
|
633 // reverse_copy ---------------------------------
|
Chris@16
|
634
|
Chris@16
|
635 struct reverse_copy {
|
Chris@16
|
636
|
Chris@16
|
637 template <class Args>
|
Chris@16
|
638 struct sig {
|
Chris@16
|
639 typedef typename boost::remove_const<
|
Chris@16
|
640 typename boost::tuples::element<3, Args>::type
|
Chris@16
|
641 >::type type;
|
Chris@16
|
642 };
|
Chris@16
|
643
|
Chris@16
|
644 template <class A, class C >
|
Chris@16
|
645 C
|
Chris@16
|
646 operator()(A a, A b, C c) const
|
Chris@16
|
647 { return ::std::reverse_copy(a, b, c); }
|
Chris@16
|
648
|
Chris@16
|
649 };
|
Chris@16
|
650
|
Chris@16
|
651 // rotate ---------------------------------
|
Chris@16
|
652
|
Chris@16
|
653 struct rotate {
|
Chris@16
|
654
|
Chris@16
|
655 template <class Args>
|
Chris@16
|
656 struct sig {
|
Chris@16
|
657 typedef void type;
|
Chris@16
|
658 };
|
Chris@16
|
659
|
Chris@16
|
660 template <class A>
|
Chris@16
|
661 void
|
Chris@16
|
662 operator()(A a, A b, A c) const
|
Chris@16
|
663 { ::std::rotate(a, b, c); }
|
Chris@16
|
664
|
Chris@16
|
665 };
|
Chris@16
|
666
|
Chris@16
|
667 // rotate_copy ---------------------------------
|
Chris@16
|
668
|
Chris@16
|
669 struct rotate_copy {
|
Chris@16
|
670
|
Chris@16
|
671 template <class Args>
|
Chris@16
|
672 struct sig {
|
Chris@16
|
673 typedef typename boost::remove_const<
|
Chris@16
|
674 typename boost::tuples::element<3, Args>::type
|
Chris@16
|
675 >::type type;
|
Chris@16
|
676 };
|
Chris@16
|
677
|
Chris@16
|
678 template <class A, class D>
|
Chris@16
|
679 D
|
Chris@16
|
680 operator()(A a, A b, A c, D d) const
|
Chris@16
|
681 { return ::std::rotate_copy(a, b, c, d); }
|
Chris@16
|
682
|
Chris@16
|
683 };
|
Chris@16
|
684
|
Chris@16
|
685 // random_shuffle ---------------------------------
|
Chris@16
|
686
|
Chris@16
|
687 struct random_shuffle {
|
Chris@16
|
688
|
Chris@16
|
689 template <class Args>
|
Chris@16
|
690 struct sig {
|
Chris@16
|
691 typedef void type;
|
Chris@16
|
692 };
|
Chris@16
|
693
|
Chris@16
|
694 template <class A>
|
Chris@16
|
695 void
|
Chris@16
|
696 operator()(A a, A b) const
|
Chris@16
|
697 { ::std::random_shuffle(a, b); }
|
Chris@16
|
698
|
Chris@16
|
699 template <class A, class C>
|
Chris@16
|
700 void
|
Chris@16
|
701 operator()(A a, A b, const C& c) const
|
Chris@16
|
702 { ::std::random_shuffle(a, b, c); }
|
Chris@16
|
703
|
Chris@16
|
704 };
|
Chris@16
|
705
|
Chris@16
|
706
|
Chris@16
|
707 // partition ---------------------------------
|
Chris@16
|
708
|
Chris@16
|
709 struct partition {
|
Chris@16
|
710
|
Chris@16
|
711 template <class Args>
|
Chris@16
|
712 struct sig {
|
Chris@16
|
713 typedef typename boost::remove_const<
|
Chris@16
|
714 typename boost::tuples::element<1, Args>::type
|
Chris@16
|
715 >::type type;
|
Chris@16
|
716 };
|
Chris@16
|
717
|
Chris@16
|
718 template <class A, class C>
|
Chris@16
|
719 A
|
Chris@16
|
720 operator()(A a, A b, C c) const
|
Chris@16
|
721 { return ::std::partition(a, b, c); }
|
Chris@16
|
722
|
Chris@16
|
723 };
|
Chris@16
|
724
|
Chris@16
|
725 // stable_partition ---------------------------------
|
Chris@16
|
726
|
Chris@16
|
727 struct stable_partition {
|
Chris@16
|
728
|
Chris@16
|
729 template <class Args>
|
Chris@16
|
730 struct sig {
|
Chris@16
|
731 typedef typename boost::remove_const<
|
Chris@16
|
732 typename boost::tuples::element<1, Args>::type
|
Chris@16
|
733 >::type type;
|
Chris@16
|
734 };
|
Chris@16
|
735
|
Chris@16
|
736 template <class A, class C>
|
Chris@16
|
737 A
|
Chris@16
|
738 operator()(A a, A b, C c) const
|
Chris@16
|
739 { return ::std::stable_partition(a, b, c); }
|
Chris@16
|
740
|
Chris@16
|
741 };
|
Chris@16
|
742
|
Chris@16
|
743 // sort ---------------------------------
|
Chris@16
|
744
|
Chris@16
|
745 struct sort {
|
Chris@16
|
746
|
Chris@16
|
747 template <class Args>
|
Chris@16
|
748 struct sig {
|
Chris@16
|
749 typedef void type;
|
Chris@16
|
750 };
|
Chris@16
|
751
|
Chris@16
|
752 template <class A>
|
Chris@16
|
753 void
|
Chris@16
|
754 operator()(A a, A b) const
|
Chris@16
|
755 { ::std::sort(a, b); }
|
Chris@16
|
756
|
Chris@16
|
757 template <class A, class C>
|
Chris@16
|
758 void
|
Chris@16
|
759 operator()(A a, A b, C c) const
|
Chris@16
|
760 { ::std::sort(a, b, c); }
|
Chris@16
|
761
|
Chris@16
|
762 };
|
Chris@16
|
763
|
Chris@16
|
764 // stable_sort ---------------------------------
|
Chris@16
|
765
|
Chris@16
|
766 struct stable_sort {
|
Chris@16
|
767
|
Chris@16
|
768 template <class Args>
|
Chris@16
|
769 struct sig {
|
Chris@16
|
770 typedef void type;
|
Chris@16
|
771 };
|
Chris@16
|
772
|
Chris@16
|
773 template <class A>
|
Chris@16
|
774 void
|
Chris@16
|
775 operator()(A a, A b) const
|
Chris@16
|
776 { ::std::stable_sort(a, b); }
|
Chris@16
|
777
|
Chris@16
|
778 template <class A, class C>
|
Chris@16
|
779 void
|
Chris@16
|
780 operator()(A a, A b, C c) const
|
Chris@16
|
781 { ::std::stable_sort(a, b, c); }
|
Chris@16
|
782
|
Chris@16
|
783 };
|
Chris@16
|
784
|
Chris@16
|
785 // partial_sort ---------------------------------
|
Chris@16
|
786
|
Chris@16
|
787 struct partial_sort {
|
Chris@16
|
788
|
Chris@16
|
789 template <class Args>
|
Chris@16
|
790 struct sig {
|
Chris@16
|
791 typedef void type;
|
Chris@16
|
792 };
|
Chris@16
|
793
|
Chris@16
|
794 template <class A>
|
Chris@16
|
795 void
|
Chris@16
|
796 operator()(A a, A b, A c) const
|
Chris@16
|
797 { ::std::partial_sort(a, b, c); }
|
Chris@16
|
798
|
Chris@16
|
799 template <class A, class D>
|
Chris@16
|
800 void
|
Chris@16
|
801 operator()(A a, A b, A c, D d) const
|
Chris@16
|
802 { ::std::partial_sort(a, b, c, d); }
|
Chris@16
|
803
|
Chris@16
|
804 };
|
Chris@16
|
805
|
Chris@16
|
806 // partial_sort_copy ---------------------------------
|
Chris@16
|
807
|
Chris@16
|
808 struct partial_sort_copy {
|
Chris@16
|
809
|
Chris@16
|
810 template <class Args>
|
Chris@16
|
811 struct sig {
|
Chris@16
|
812 typedef typename boost::remove_const<
|
Chris@16
|
813 typename boost::tuples::element<3, Args>::type
|
Chris@16
|
814 >::type type;
|
Chris@16
|
815 };
|
Chris@16
|
816
|
Chris@16
|
817 template <class A, class C>
|
Chris@16
|
818 C
|
Chris@16
|
819 operator()(A a, A b, C c, C d) const
|
Chris@16
|
820 { return ::std::partial_sort_copy(a, b, c, d); }
|
Chris@16
|
821
|
Chris@16
|
822 template <class A, class C, class E >
|
Chris@16
|
823 C
|
Chris@16
|
824 operator()(A a, A b, C c, C d, E e) const
|
Chris@16
|
825 { return ::std::partial_sort_copy(a, b, c, d, e); }
|
Chris@16
|
826 };
|
Chris@16
|
827
|
Chris@16
|
828 // nth_element ---------------------------------
|
Chris@16
|
829
|
Chris@16
|
830 struct nth_element {
|
Chris@16
|
831
|
Chris@16
|
832 template <class Args>
|
Chris@16
|
833 struct sig {
|
Chris@16
|
834 typedef void type;
|
Chris@16
|
835 };
|
Chris@16
|
836
|
Chris@16
|
837 template <class A>
|
Chris@16
|
838 void
|
Chris@16
|
839 operator()(A a, A b, A c) const
|
Chris@16
|
840 { ::std::nth_element(a, b, c); }
|
Chris@16
|
841
|
Chris@16
|
842 template <class A, class D>
|
Chris@16
|
843 void
|
Chris@16
|
844 operator()(A a, A b, A c, D d) const
|
Chris@16
|
845 { ::std::nth_element(a, b, c, d); }
|
Chris@16
|
846
|
Chris@16
|
847 };
|
Chris@16
|
848
|
Chris@16
|
849 // lower_bound ---------------------------------
|
Chris@16
|
850
|
Chris@16
|
851 struct lower_bound {
|
Chris@16
|
852
|
Chris@16
|
853 template <class Args>
|
Chris@16
|
854 struct sig {
|
Chris@16
|
855 typedef typename boost::remove_const<
|
Chris@16
|
856 typename boost::tuples::element<1, Args>::type
|
Chris@16
|
857 >::type type;
|
Chris@16
|
858 };
|
Chris@16
|
859
|
Chris@16
|
860 template <class A, class C>
|
Chris@16
|
861 A
|
Chris@16
|
862 operator()(A a, A b, const C& c) const
|
Chris@16
|
863 { return ::std::lower_bound(a, b, c); }
|
Chris@16
|
864
|
Chris@16
|
865 template <class A, class C, class D>
|
Chris@16
|
866 A
|
Chris@16
|
867 operator()(A a, A b, const C& c, D d) const
|
Chris@16
|
868 { return ::std::lower_bound(a, b, c, d); }
|
Chris@16
|
869
|
Chris@16
|
870 };
|
Chris@16
|
871
|
Chris@16
|
872 // upper_bound ---------------------------------
|
Chris@16
|
873
|
Chris@16
|
874 struct upper_bound {
|
Chris@16
|
875
|
Chris@16
|
876 template <class Args>
|
Chris@16
|
877 struct sig {
|
Chris@16
|
878 typedef typename boost::remove_const<
|
Chris@16
|
879 typename boost::tuples::element<1, Args>::type
|
Chris@16
|
880 >::type type;
|
Chris@16
|
881 };
|
Chris@16
|
882
|
Chris@16
|
883 template <class A, class C>
|
Chris@16
|
884 A
|
Chris@16
|
885 operator()(A a, A b, const C& c) const
|
Chris@16
|
886 { return ::std::upper_bound(a, b, c); }
|
Chris@16
|
887
|
Chris@16
|
888 template <class A, class C, class D>
|
Chris@16
|
889 A
|
Chris@16
|
890 operator()(A a, A b, const C& c, D d) const
|
Chris@16
|
891 { return ::std::upper_bound(a, b, c, d); }
|
Chris@16
|
892
|
Chris@16
|
893 };
|
Chris@16
|
894
|
Chris@16
|
895 // equal_range ---------------------------------
|
Chris@16
|
896
|
Chris@16
|
897 struct equal_range {
|
Chris@16
|
898
|
Chris@16
|
899 template <class Args>
|
Chris@16
|
900 struct sig {
|
Chris@16
|
901 typedef typename boost::remove_const<
|
Chris@16
|
902 typename boost::tuples::element<1, Args>::type
|
Chris@16
|
903 >::type element_type;
|
Chris@16
|
904
|
Chris@16
|
905 typedef ::std::pair< element_type, element_type > type;
|
Chris@16
|
906 };
|
Chris@16
|
907
|
Chris@16
|
908 template <class A, class C>
|
Chris@16
|
909 ::std::pair<A,A>
|
Chris@16
|
910 operator()(A a, A b, const C& c) const
|
Chris@16
|
911 { return ::std::equal_range(a, b, c); }
|
Chris@16
|
912
|
Chris@16
|
913 template <class A, class C, class D>
|
Chris@16
|
914 ::std::pair<A,A>
|
Chris@16
|
915 operator()(A a, A b, const C& c, D d) const
|
Chris@16
|
916 { return ::std::equal_range(a, b, c, d); }
|
Chris@16
|
917
|
Chris@16
|
918 };
|
Chris@16
|
919
|
Chris@16
|
920 // binary_search ---------------------------------
|
Chris@16
|
921
|
Chris@16
|
922 struct binary_search {
|
Chris@16
|
923
|
Chris@16
|
924 template <class Args>
|
Chris@16
|
925 struct sig {
|
Chris@16
|
926 typedef bool type;
|
Chris@16
|
927 };
|
Chris@16
|
928
|
Chris@16
|
929 template <class A, class C >
|
Chris@16
|
930 bool
|
Chris@16
|
931 operator()(A a, A b, const C& c) const
|
Chris@16
|
932 { return ::std::binary_search(a, b, c); }
|
Chris@16
|
933
|
Chris@16
|
934 template <class A, class C, class D>
|
Chris@16
|
935 bool
|
Chris@16
|
936 operator()(A a, A b, const C& c, D d) const
|
Chris@16
|
937 { return ::std::binary_search(a, b, c, d); }
|
Chris@16
|
938
|
Chris@16
|
939 };
|
Chris@16
|
940
|
Chris@16
|
941 // merge --------------------------------
|
Chris@16
|
942
|
Chris@16
|
943 struct merge {
|
Chris@16
|
944
|
Chris@16
|
945 template <class Args>
|
Chris@16
|
946 struct sig {
|
Chris@16
|
947 typedef typename boost::remove_const<
|
Chris@16
|
948 typename boost::tuples::element<5, Args>::type
|
Chris@16
|
949 >::type type;
|
Chris@16
|
950 };
|
Chris@16
|
951
|
Chris@16
|
952 template <class A, class C, class E>
|
Chris@16
|
953 E
|
Chris@16
|
954 operator()(A a, A b, C c, C d, E e) const
|
Chris@16
|
955 { return std::merge(a, b, c, d, e);}
|
Chris@16
|
956
|
Chris@16
|
957 template <class A, class C, class E, class F>
|
Chris@16
|
958 E
|
Chris@16
|
959 operator()(A a, A b, C c, C d, E e, F f) const
|
Chris@16
|
960 { return std::merge(a, b, c, d, e, f);}
|
Chris@16
|
961
|
Chris@16
|
962 };
|
Chris@16
|
963
|
Chris@16
|
964 // inplace_merge ---------------------------------
|
Chris@16
|
965
|
Chris@16
|
966 struct inplace_merge {
|
Chris@16
|
967
|
Chris@16
|
968 template <class Args>
|
Chris@16
|
969 struct sig {
|
Chris@16
|
970 typedef void type;
|
Chris@16
|
971 };
|
Chris@16
|
972
|
Chris@16
|
973 template <class A>
|
Chris@16
|
974 void
|
Chris@16
|
975 operator()(A a, A b, A c) const
|
Chris@16
|
976 { ::std::inplace_merge(a, b, c); }
|
Chris@16
|
977
|
Chris@16
|
978 template <class A, class D>
|
Chris@16
|
979 void
|
Chris@16
|
980 operator()(A a, A b, A c, D d) const
|
Chris@16
|
981 { ::std::inplace_merge(a, b, c, d); }
|
Chris@16
|
982
|
Chris@16
|
983 };
|
Chris@16
|
984
|
Chris@16
|
985 // includes ---------------------------------
|
Chris@16
|
986
|
Chris@16
|
987 struct includes {
|
Chris@16
|
988
|
Chris@16
|
989 template <class Args>
|
Chris@16
|
990 struct sig {
|
Chris@16
|
991 typedef bool type;
|
Chris@16
|
992 };
|
Chris@16
|
993
|
Chris@16
|
994 template <class A, class C>
|
Chris@16
|
995 bool
|
Chris@16
|
996 operator()(A a, A b, C c, C d) const
|
Chris@16
|
997 { return ::std::includes(a, b, c, d); }
|
Chris@16
|
998
|
Chris@16
|
999 template <class A, class C, class E>
|
Chris@16
|
1000 bool
|
Chris@16
|
1001 operator()(A a, A b, C c, C d, E e) const
|
Chris@16
|
1002 { return ::std::includes(a, b, c, d, e); }
|
Chris@16
|
1003
|
Chris@16
|
1004 };
|
Chris@16
|
1005
|
Chris@16
|
1006 // set_union --------------------------------
|
Chris@16
|
1007
|
Chris@16
|
1008 struct set_union {
|
Chris@16
|
1009
|
Chris@16
|
1010 template <class Args>
|
Chris@16
|
1011 struct sig {
|
Chris@16
|
1012 typedef typename boost::remove_const<
|
Chris@16
|
1013 typename boost::tuples::element<5, Args>::type
|
Chris@16
|
1014 >::type type;
|
Chris@16
|
1015 };
|
Chris@16
|
1016
|
Chris@16
|
1017 template <class A, class C, class E>
|
Chris@16
|
1018 E
|
Chris@16
|
1019 operator()(A a, A b, C c, C d, E e) const
|
Chris@16
|
1020 { return std::set_union(a, b, c, d, e);}
|
Chris@16
|
1021
|
Chris@16
|
1022 template <class A, class C, class E, class F>
|
Chris@16
|
1023 E
|
Chris@16
|
1024 operator()(A a, A b, C c, C d, E e, F f) const
|
Chris@16
|
1025 { return std::set_union(a, b, c, d, e, f);}
|
Chris@16
|
1026
|
Chris@16
|
1027 };
|
Chris@16
|
1028
|
Chris@16
|
1029 // set_intersection --------------------------------
|
Chris@16
|
1030
|
Chris@16
|
1031 struct set_intersection {
|
Chris@16
|
1032
|
Chris@16
|
1033 template <class Args>
|
Chris@16
|
1034 struct sig {
|
Chris@16
|
1035 typedef typename boost::remove_const<
|
Chris@16
|
1036 typename boost::tuples::element<5, Args>::type
|
Chris@16
|
1037 >::type type;
|
Chris@16
|
1038 };
|
Chris@16
|
1039
|
Chris@16
|
1040 template <class A, class C, class E>
|
Chris@16
|
1041 E
|
Chris@16
|
1042 operator()(A a, A b, C c, C d, E e) const
|
Chris@16
|
1043 { return std::set_intersection(a, b, c, d, e);}
|
Chris@16
|
1044
|
Chris@16
|
1045 template <class A, class C, class E, class F>
|
Chris@16
|
1046 E
|
Chris@16
|
1047 operator()(A a, A b, C c, C d, E e, F f) const
|
Chris@16
|
1048 { return std::set_intersection(a, b, c, d, e, f);}
|
Chris@16
|
1049
|
Chris@16
|
1050 };
|
Chris@16
|
1051
|
Chris@16
|
1052 // set_difference --------------------------------
|
Chris@16
|
1053
|
Chris@16
|
1054 struct set_difference {
|
Chris@16
|
1055
|
Chris@16
|
1056 template <class Args>
|
Chris@16
|
1057 struct sig {
|
Chris@16
|
1058 typedef typename boost::remove_const<
|
Chris@16
|
1059 typename boost::tuples::element<5, Args>::type
|
Chris@16
|
1060 >::type type;
|
Chris@16
|
1061 };
|
Chris@16
|
1062
|
Chris@16
|
1063 template <class A, class C, class E>
|
Chris@16
|
1064 E
|
Chris@16
|
1065 operator()(A a, A b, C c, C d, E e) const
|
Chris@16
|
1066 { return std::set_difference(a, b, c, d, e);}
|
Chris@16
|
1067
|
Chris@16
|
1068 template <class A, class C, class E, class F>
|
Chris@16
|
1069 E
|
Chris@16
|
1070 operator()(A a, A b, C c, C d, E e, F f) const
|
Chris@16
|
1071 { return std::set_difference(a, b, c, d, e, f);}
|
Chris@16
|
1072
|
Chris@16
|
1073 };
|
Chris@16
|
1074
|
Chris@16
|
1075
|
Chris@16
|
1076 // set_symmetric_difference --------------------------------
|
Chris@16
|
1077
|
Chris@16
|
1078 struct set_symmetric_difference {
|
Chris@16
|
1079
|
Chris@16
|
1080 template <class Args>
|
Chris@16
|
1081 struct sig {
|
Chris@16
|
1082 typedef typename boost::remove_const<
|
Chris@16
|
1083 typename boost::tuples::element<5, Args>::type
|
Chris@16
|
1084 >::type type;
|
Chris@16
|
1085 };
|
Chris@16
|
1086
|
Chris@16
|
1087 template <class A, class C, class E>
|
Chris@16
|
1088 E
|
Chris@16
|
1089 operator()(A a, A b, C c, C d, E e) const
|
Chris@16
|
1090 { return std::set_symmetric_difference(a, b, c, d, e);}
|
Chris@16
|
1091
|
Chris@16
|
1092 template <class A, class C, class E, class F>
|
Chris@16
|
1093 E
|
Chris@16
|
1094 operator()(A a, A b, C c, C d, E e, F f) const
|
Chris@16
|
1095 { return std::set_symmetric_difference(a, b, c, d, e, f);}
|
Chris@16
|
1096
|
Chris@16
|
1097 };
|
Chris@16
|
1098
|
Chris@16
|
1099 // push_heap ---------------------------------
|
Chris@16
|
1100
|
Chris@16
|
1101 struct push_heap {
|
Chris@16
|
1102
|
Chris@16
|
1103 template <class Args>
|
Chris@16
|
1104 struct sig {
|
Chris@16
|
1105 typedef void type;
|
Chris@16
|
1106 };
|
Chris@16
|
1107
|
Chris@16
|
1108 template <class A>
|
Chris@16
|
1109 void
|
Chris@16
|
1110 operator()(A a, A b) const
|
Chris@16
|
1111 { ::std::push_heap(a, b); }
|
Chris@16
|
1112
|
Chris@16
|
1113 template <class A, class C>
|
Chris@16
|
1114 void
|
Chris@16
|
1115 operator()(A a, A b, C c) const
|
Chris@16
|
1116 { ::std::push_heap(a, b, c); }
|
Chris@16
|
1117
|
Chris@16
|
1118 };
|
Chris@16
|
1119
|
Chris@16
|
1120 // pop_heap ---------------------------------
|
Chris@16
|
1121
|
Chris@16
|
1122 struct pop_heap {
|
Chris@16
|
1123
|
Chris@16
|
1124 template <class Args>
|
Chris@16
|
1125 struct sig {
|
Chris@16
|
1126 typedef void type;
|
Chris@16
|
1127 };
|
Chris@16
|
1128
|
Chris@16
|
1129 template <class A>
|
Chris@16
|
1130 void
|
Chris@16
|
1131 operator()(A a, A b) const
|
Chris@16
|
1132 { ::std::pop_heap(a, b); }
|
Chris@16
|
1133
|
Chris@16
|
1134 template <class A, class C>
|
Chris@16
|
1135 void
|
Chris@16
|
1136 operator()(A a, A b, C c) const
|
Chris@16
|
1137 { ::std::pop_heap(a, b, c); }
|
Chris@16
|
1138
|
Chris@16
|
1139 };
|
Chris@16
|
1140
|
Chris@16
|
1141
|
Chris@16
|
1142 // make_heap ---------------------------------
|
Chris@16
|
1143
|
Chris@16
|
1144 struct make_heap {
|
Chris@16
|
1145
|
Chris@16
|
1146 template <class Args>
|
Chris@16
|
1147 struct sig {
|
Chris@16
|
1148 typedef void type;
|
Chris@16
|
1149 };
|
Chris@16
|
1150
|
Chris@16
|
1151 template <class A>
|
Chris@16
|
1152 void
|
Chris@16
|
1153 operator()(A a, A b) const
|
Chris@16
|
1154 { ::std::make_heap(a, b); }
|
Chris@16
|
1155
|
Chris@16
|
1156 template <class A, class C>
|
Chris@16
|
1157 void
|
Chris@16
|
1158 operator()(A a, A b, C c) const
|
Chris@16
|
1159 { ::std::make_heap(a, b, c); }
|
Chris@16
|
1160
|
Chris@16
|
1161 };
|
Chris@16
|
1162
|
Chris@16
|
1163 // sort_heap ---------------------------------
|
Chris@16
|
1164
|
Chris@16
|
1165 struct sort_heap {
|
Chris@16
|
1166
|
Chris@16
|
1167 template <class Args>
|
Chris@16
|
1168 struct sig {
|
Chris@16
|
1169 typedef void type;
|
Chris@16
|
1170 };
|
Chris@16
|
1171
|
Chris@16
|
1172 template <class A>
|
Chris@16
|
1173 void
|
Chris@16
|
1174 operator()(A a, A b) const
|
Chris@16
|
1175 { ::std::sort_heap(a, b); }
|
Chris@16
|
1176
|
Chris@16
|
1177 template <class A, class C>
|
Chris@16
|
1178 void
|
Chris@16
|
1179 operator()(A a, A b, C c) const
|
Chris@16
|
1180 { ::std::sort_heap(a, b, c); }
|
Chris@16
|
1181
|
Chris@16
|
1182 };
|
Chris@16
|
1183
|
Chris@16
|
1184 // min ---------------------------------
|
Chris@16
|
1185
|
Chris@16
|
1186 struct min {
|
Chris@16
|
1187
|
Chris@16
|
1188 template <class Args>
|
Chris@16
|
1189 struct sig {
|
Chris@16
|
1190 typedef typename boost::remove_const<
|
Chris@16
|
1191 typename boost::tuples::element<1, Args>::type
|
Chris@16
|
1192 >::type type;
|
Chris@16
|
1193 };
|
Chris@16
|
1194
|
Chris@16
|
1195 template <class A>
|
Chris@16
|
1196 A
|
Chris@16
|
1197 operator()(const A& a, const A& b) const
|
Chris@16
|
1198 { return (::std::min)(a, b); }
|
Chris@16
|
1199
|
Chris@16
|
1200 template <class A, class C>
|
Chris@16
|
1201 A
|
Chris@16
|
1202 operator()(const A& a, const A& b, C c) const
|
Chris@16
|
1203 { return (::std::min)(a, b, c); }
|
Chris@16
|
1204
|
Chris@16
|
1205 };
|
Chris@16
|
1206
|
Chris@16
|
1207 // max ---------------------------------
|
Chris@16
|
1208
|
Chris@16
|
1209 struct max {
|
Chris@16
|
1210
|
Chris@16
|
1211 template <class Args>
|
Chris@16
|
1212 struct sig {
|
Chris@16
|
1213 typedef typename boost::remove_const<
|
Chris@16
|
1214 typename boost::tuples::element<1, Args>::type
|
Chris@16
|
1215 >::type type;
|
Chris@16
|
1216 };
|
Chris@16
|
1217
|
Chris@16
|
1218 template <class A>
|
Chris@16
|
1219 A
|
Chris@16
|
1220 operator()(const A& a, const A& b) const
|
Chris@16
|
1221 { return (::std::max)(a, b); }
|
Chris@16
|
1222
|
Chris@16
|
1223 template <class A, class C>
|
Chris@16
|
1224 A
|
Chris@16
|
1225 operator()(const A& a, const A& b, C c) const
|
Chris@16
|
1226 { return (::std::max)(a, b, c); }
|
Chris@16
|
1227
|
Chris@16
|
1228 };
|
Chris@16
|
1229
|
Chris@16
|
1230 struct min_element {
|
Chris@16
|
1231
|
Chris@16
|
1232 template <class Args>
|
Chris@16
|
1233 struct sig {
|
Chris@16
|
1234 typedef typename boost::remove_const<
|
Chris@16
|
1235 typename boost::tuples::element<1, Args>::type
|
Chris@16
|
1236 >::type type;
|
Chris@16
|
1237 };
|
Chris@16
|
1238
|
Chris@16
|
1239 template <class A>
|
Chris@16
|
1240 A
|
Chris@16
|
1241 operator()(A a, A b) const
|
Chris@16
|
1242 { return ::std::min_element(a, b); }
|
Chris@16
|
1243
|
Chris@16
|
1244 template <class A, class C>
|
Chris@16
|
1245 A
|
Chris@16
|
1246 operator()(A a, A b, C c) const
|
Chris@16
|
1247 { return ::std::min_element(a, b, c); }
|
Chris@16
|
1248
|
Chris@16
|
1249 };
|
Chris@16
|
1250
|
Chris@16
|
1251 // max_element ---------------------------------
|
Chris@16
|
1252
|
Chris@16
|
1253 struct max_element {
|
Chris@16
|
1254
|
Chris@16
|
1255 template <class Args>
|
Chris@16
|
1256 struct sig {
|
Chris@16
|
1257 typedef typename boost::remove_const<
|
Chris@16
|
1258 typename boost::tuples::element<1, Args>::type
|
Chris@16
|
1259 >::type type;
|
Chris@16
|
1260 };
|
Chris@16
|
1261
|
Chris@16
|
1262 template <class A>
|
Chris@16
|
1263 A
|
Chris@16
|
1264 operator()(A a, A b) const
|
Chris@16
|
1265 { return ::std::max_element(a, b); }
|
Chris@16
|
1266
|
Chris@16
|
1267 template <class A, class C>
|
Chris@16
|
1268 A
|
Chris@16
|
1269 operator()(A a, A b, C c) const
|
Chris@16
|
1270 { return ::std::max_element(a, b, c); }
|
Chris@16
|
1271
|
Chris@16
|
1272 };
|
Chris@16
|
1273
|
Chris@16
|
1274
|
Chris@16
|
1275 // lexicographical_compare ---------------------------------
|
Chris@16
|
1276
|
Chris@16
|
1277 struct lexicographical_compare {
|
Chris@16
|
1278
|
Chris@16
|
1279 template <class Args>
|
Chris@16
|
1280 struct sig {
|
Chris@16
|
1281 typedef bool type;
|
Chris@16
|
1282 };
|
Chris@16
|
1283
|
Chris@16
|
1284 template <class A, class C>
|
Chris@16
|
1285 bool
|
Chris@16
|
1286 operator()(A a, A b, C c, C d) const
|
Chris@16
|
1287 { return ::std::lexicographical_compare(a, b, c, d); }
|
Chris@16
|
1288
|
Chris@16
|
1289 template <class A, class C, class E>
|
Chris@16
|
1290 bool
|
Chris@16
|
1291 operator()(A a, A b, C c, C d, E e) const
|
Chris@16
|
1292 { return ::std::lexicographical_compare(a, b, c, d, e); }
|
Chris@16
|
1293
|
Chris@16
|
1294 };
|
Chris@16
|
1295
|
Chris@16
|
1296 // next_permutation ---------------------------------
|
Chris@16
|
1297
|
Chris@16
|
1298 struct next_permutation {
|
Chris@16
|
1299
|
Chris@16
|
1300 template <class Args>
|
Chris@16
|
1301 struct sig {
|
Chris@16
|
1302 typedef bool type;
|
Chris@16
|
1303 };
|
Chris@16
|
1304
|
Chris@16
|
1305 template <class A>
|
Chris@16
|
1306 bool
|
Chris@16
|
1307 operator()(A a, A b) const
|
Chris@16
|
1308 { return ::std::next_permutation(a, b); }
|
Chris@16
|
1309
|
Chris@16
|
1310 template <class A, class C >
|
Chris@16
|
1311 bool
|
Chris@16
|
1312 operator()(A a, A b, C c) const
|
Chris@16
|
1313 { return ::std::next_permutation(a, b, c); }
|
Chris@16
|
1314
|
Chris@16
|
1315 };
|
Chris@16
|
1316
|
Chris@16
|
1317 // prev_permutation ---------------------------------
|
Chris@16
|
1318
|
Chris@16
|
1319 struct prev_permutation {
|
Chris@16
|
1320
|
Chris@16
|
1321 template <class Args>
|
Chris@16
|
1322 struct sig {
|
Chris@16
|
1323 typedef bool type;
|
Chris@16
|
1324 };
|
Chris@16
|
1325
|
Chris@16
|
1326 template <class A>
|
Chris@16
|
1327 bool
|
Chris@16
|
1328 operator()(A a, A b) const
|
Chris@16
|
1329 { return ::std::prev_permutation(a, b); }
|
Chris@16
|
1330
|
Chris@16
|
1331 template <class A, class C >
|
Chris@16
|
1332 bool
|
Chris@16
|
1333 operator()(A a, A b, C c) const
|
Chris@16
|
1334 { return ::std::prev_permutation(a, b, c); }
|
Chris@16
|
1335
|
Chris@16
|
1336 };
|
Chris@16
|
1337
|
Chris@16
|
1338
|
Chris@16
|
1339
|
Chris@16
|
1340
|
Chris@16
|
1341
|
Chris@16
|
1342 } // end of ll namespace
|
Chris@16
|
1343
|
Chris@16
|
1344 // There is no good way to call an overloaded member function in a
|
Chris@16
|
1345 // lambda expression.
|
Chris@16
|
1346 // The macro below defines a function object class for calling a
|
Chris@16
|
1347 // const_iterator returning member function of a container.
|
Chris@16
|
1348
|
Chris@16
|
1349 #define CALL_MEMBER(X) \
|
Chris@16
|
1350 struct call_##X { \
|
Chris@16
|
1351 template <class Args> \
|
Chris@16
|
1352 struct sig { \
|
Chris@16
|
1353 typedef typename boost::remove_const< \
|
Chris@16
|
1354 typename boost::tuples::element<1, Args>::type \
|
Chris@16
|
1355 >::type::const_iterator type; \
|
Chris@16
|
1356 }; \
|
Chris@16
|
1357 \
|
Chris@16
|
1358 template<class T> \
|
Chris@16
|
1359 typename T::const_iterator \
|
Chris@16
|
1360 operator()(const T& t) const \
|
Chris@16
|
1361 { \
|
Chris@16
|
1362 return t.X(); \
|
Chris@16
|
1363 } \
|
Chris@16
|
1364 };
|
Chris@16
|
1365
|
Chris@16
|
1366 // create call_begin and call_end classes
|
Chris@16
|
1367 CALL_MEMBER(begin)
|
Chris@16
|
1368 CALL_MEMBER(end)
|
Chris@16
|
1369
|
Chris@16
|
1370 #undef CALL_MEMBER
|
Chris@16
|
1371
|
Chris@16
|
1372 } // end of lambda namespace
|
Chris@16
|
1373 } // end of boost namespace
|
Chris@16
|
1374
|
Chris@16
|
1375
|
Chris@16
|
1376
|
Chris@16
|
1377 #endif
|