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