1 // -- algorithm.hpp -- Boost Lambda Library ----------------------------------- 2 // Copyright (C) 2002 Jaakko Jarvi (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 #ifndef BOOST_NO_CXX98_RANDOM_SHUFFLE 688 689 struct random_shuffle { 690 691 template <class Args> 692 struct sig { 693 typedef void type; 694 }; 695 696 template <class A> 697 void operator ()boost::lambda::ll::random_shuffle698 operator()(A a, A b) const 699 { ::std::random_shuffle(a, b); } 700 701 template <class A, class C> 702 void operator ()boost::lambda::ll::random_shuffle703 operator()(A a, A b, const C& c) const 704 { ::std::random_shuffle(a, b, c); } 705 706 }; 707 708 #endif 709 710 // partition --------------------------------- 711 712 struct partition { 713 714 template <class Args> 715 struct sig { 716 typedef typename boost::remove_const< 717 typename boost::tuples::element<1, Args>::type 718 >::type type; 719 }; 720 721 template <class A, class C> 722 A 723 operator()(A a, A b, C c) const 724 { return ::std::partition(a, b, c); } 725 726 }; 727 728 // stable_partition --------------------------------- 729 730 struct stable_partition { 731 732 template <class Args> 733 struct sig { 734 typedef typename boost::remove_const< 735 typename boost::tuples::element<1, Args>::type 736 >::type type; 737 }; 738 739 template <class A, class C> 740 A 741 operator()(A a, A b, C c) const 742 { return ::std::stable_partition(a, b, c); } 743 744 }; 745 746 // sort --------------------------------- 747 748 struct sort { 749 750 template <class Args> 751 struct sig { 752 typedef void type; 753 }; 754 755 template <class A> 756 void operator ()boost::lambda::ll::sort757 operator()(A a, A b) const 758 { ::std::sort(a, b); } 759 760 template <class A, class C> 761 void operator ()boost::lambda::ll::sort762 operator()(A a, A b, C c) const 763 { ::std::sort(a, b, c); } 764 765 }; 766 767 // stable_sort --------------------------------- 768 769 struct stable_sort { 770 771 template <class Args> 772 struct sig { 773 typedef void type; 774 }; 775 776 template <class A> 777 void operator ()boost::lambda::ll::stable_sort778 operator()(A a, A b) const 779 { ::std::stable_sort(a, b); } 780 781 template <class A, class C> 782 void operator ()boost::lambda::ll::stable_sort783 operator()(A a, A b, C c) const 784 { ::std::stable_sort(a, b, c); } 785 786 }; 787 788 // partial_sort --------------------------------- 789 790 struct partial_sort { 791 792 template <class Args> 793 struct sig { 794 typedef void type; 795 }; 796 797 template <class A> 798 void operator ()boost::lambda::ll::partial_sort799 operator()(A a, A b, A c) const 800 { ::std::partial_sort(a, b, c); } 801 802 template <class A, class D> 803 void operator ()boost::lambda::ll::partial_sort804 operator()(A a, A b, A c, D d) const 805 { ::std::partial_sort(a, b, c, d); } 806 807 }; 808 809 // partial_sort_copy --------------------------------- 810 811 struct partial_sort_copy { 812 813 template <class Args> 814 struct sig { 815 typedef typename boost::remove_const< 816 typename boost::tuples::element<3, Args>::type 817 >::type type; 818 }; 819 820 template <class A, class C> 821 C operator ()boost::lambda::ll::partial_sort_copy822 operator()(A a, A b, C c, C d) const 823 { return ::std::partial_sort_copy(a, b, c, d); } 824 825 template <class A, class C, class E > 826 C 827 operator()(A a, A b, C c, C d, E e) const 828 { return ::std::partial_sort_copy(a, b, c, d, e); } 829 }; 830 831 // nth_element --------------------------------- 832 833 struct nth_element { 834 835 template <class Args> 836 struct sig { 837 typedef void type; 838 }; 839 840 template <class A> 841 void operator ()boost::lambda::ll::nth_element842 operator()(A a, A b, A c) const 843 { ::std::nth_element(a, b, c); } 844 845 template <class A, class D> 846 void operator ()boost::lambda::ll::nth_element847 operator()(A a, A b, A c, D d) const 848 { ::std::nth_element(a, b, c, d); } 849 850 }; 851 852 // lower_bound --------------------------------- 853 854 struct lower_bound { 855 856 template <class Args> 857 struct sig { 858 typedef typename boost::remove_const< 859 typename boost::tuples::element<1, Args>::type 860 >::type type; 861 }; 862 863 template <class A, class C> 864 A 865 operator()(A a, A b, const C& c) const 866 { return ::std::lower_bound(a, b, c); } 867 868 template <class A, class C, class D> 869 A 870 operator()(A a, A b, const C& c, D d) const 871 { return ::std::lower_bound(a, b, c, d); } 872 873 }; 874 875 // upper_bound --------------------------------- 876 877 struct upper_bound { 878 879 template <class Args> 880 struct sig { 881 typedef typename boost::remove_const< 882 typename boost::tuples::element<1, Args>::type 883 >::type type; 884 }; 885 886 template <class A, class C> 887 A 888 operator()(A a, A b, const C& c) const 889 { return ::std::upper_bound(a, b, c); } 890 891 template <class A, class C, class D> 892 A 893 operator()(A a, A b, const C& c, D d) const 894 { return ::std::upper_bound(a, b, c, d); } 895 896 }; 897 898 // equal_range --------------------------------- 899 900 struct equal_range { 901 902 template <class Args> 903 struct sig { 904 typedef typename boost::remove_const< 905 typename boost::tuples::element<1, Args>::type 906 >::type element_type; 907 908 typedef ::std::pair< element_type, element_type > type; 909 }; 910 911 template <class A, class C> 912 ::std::pair<A,A> operator ()boost::lambda::ll::equal_range913 operator()(A a, A b, const C& c) const 914 { return ::std::equal_range(a, b, c); } 915 916 template <class A, class C, class D> 917 ::std::pair<A,A> operator ()boost::lambda::ll::equal_range918 operator()(A a, A b, const C& c, D d) const 919 { return ::std::equal_range(a, b, c, d); } 920 921 }; 922 923 // binary_search --------------------------------- 924 925 struct binary_search { 926 927 template <class Args> 928 struct sig { 929 typedef bool type; 930 }; 931 932 template <class A, class C > 933 bool operator ()boost::lambda::ll::binary_search934 operator()(A a, A b, const C& c) const 935 { return ::std::binary_search(a, b, c); } 936 937 template <class A, class C, class D> 938 bool operator ()boost::lambda::ll::binary_search939 operator()(A a, A b, const C& c, D d) const 940 { return ::std::binary_search(a, b, c, d); } 941 942 }; 943 944 // merge -------------------------------- 945 946 struct merge { 947 948 template <class Args> 949 struct sig { 950 typedef typename boost::remove_const< 951 typename boost::tuples::element<5, Args>::type 952 >::type type; 953 }; 954 955 template <class A, class C, class E> 956 E operator ()boost::lambda::ll::merge957 operator()(A a, A b, C c, C d, E e) const 958 { return std::merge(a, b, c, d, e);} 959 960 template <class A, class C, class E, class F> 961 E 962 operator()(A a, A b, C c, C d, E e, F f) const 963 { return std::merge(a, b, c, d, e, f);} 964 965 }; 966 967 // inplace_merge --------------------------------- 968 969 struct inplace_merge { 970 971 template <class Args> 972 struct sig { 973 typedef void type; 974 }; 975 976 template <class A> 977 void operator ()boost::lambda::ll::inplace_merge978 operator()(A a, A b, A c) const 979 { ::std::inplace_merge(a, b, c); } 980 981 template <class A, class D> 982 void operator ()boost::lambda::ll::inplace_merge983 operator()(A a, A b, A c, D d) const 984 { ::std::inplace_merge(a, b, c, d); } 985 986 }; 987 988 // includes --------------------------------- 989 990 struct includes { 991 992 template <class Args> 993 struct sig { 994 typedef bool type; 995 }; 996 997 template <class A, class C> 998 bool operator ()boost::lambda::ll::includes999 operator()(A a, A b, C c, C d) const 1000 { return ::std::includes(a, b, c, d); } 1001 1002 template <class A, class C, class E> 1003 bool operator ()boost::lambda::ll::includes1004 operator()(A a, A b, C c, C d, E e) const 1005 { return ::std::includes(a, b, c, d, e); } 1006 1007 }; 1008 1009 // set_union -------------------------------- 1010 1011 struct set_union { 1012 1013 template <class Args> 1014 struct sig { 1015 typedef typename boost::remove_const< 1016 typename boost::tuples::element<5, Args>::type 1017 >::type type; 1018 }; 1019 1020 template <class A, class C, class E> 1021 E operator ()boost::lambda::ll::set_union1022 operator()(A a, A b, C c, C d, E e) const 1023 { return std::set_union(a, b, c, d, e);} 1024 1025 template <class A, class C, class E, class F> 1026 E 1027 operator()(A a, A b, C c, C d, E e, F f) const 1028 { return std::set_union(a, b, c, d, e, f);} 1029 1030 }; 1031 1032 // set_intersection -------------------------------- 1033 1034 struct set_intersection { 1035 1036 template <class Args> 1037 struct sig { 1038 typedef typename boost::remove_const< 1039 typename boost::tuples::element<5, Args>::type 1040 >::type type; 1041 }; 1042 1043 template <class A, class C, class E> 1044 E operator ()boost::lambda::ll::set_intersection1045 operator()(A a, A b, C c, C d, E e) const 1046 { return std::set_intersection(a, b, c, d, e);} 1047 1048 template <class A, class C, class E, class F> 1049 E 1050 operator()(A a, A b, C c, C d, E e, F f) const 1051 { return std::set_intersection(a, b, c, d, e, f);} 1052 1053 }; 1054 1055 // set_difference -------------------------------- 1056 1057 struct set_difference { 1058 1059 template <class Args> 1060 struct sig { 1061 typedef typename boost::remove_const< 1062 typename boost::tuples::element<5, Args>::type 1063 >::type type; 1064 }; 1065 1066 template <class A, class C, class E> 1067 E operator ()boost::lambda::ll::set_difference1068 operator()(A a, A b, C c, C d, E e) const 1069 { return std::set_difference(a, b, c, d, e);} 1070 1071 template <class A, class C, class E, class F> 1072 E 1073 operator()(A a, A b, C c, C d, E e, F f) const 1074 { return std::set_difference(a, b, c, d, e, f);} 1075 1076 }; 1077 1078 1079 // set_symmetric_difference -------------------------------- 1080 1081 struct set_symmetric_difference { 1082 1083 template <class Args> 1084 struct sig { 1085 typedef typename boost::remove_const< 1086 typename boost::tuples::element<5, Args>::type 1087 >::type type; 1088 }; 1089 1090 template <class A, class C, class E> 1091 E operator ()boost::lambda::ll::set_symmetric_difference1092 operator()(A a, A b, C c, C d, E e) const 1093 { return std::set_symmetric_difference(a, b, c, d, e);} 1094 1095 template <class A, class C, class E, class F> 1096 E 1097 operator()(A a, A b, C c, C d, E e, F f) const 1098 { return std::set_symmetric_difference(a, b, c, d, e, f);} 1099 1100 }; 1101 1102 // push_heap --------------------------------- 1103 1104 struct push_heap { 1105 1106 template <class Args> 1107 struct sig { 1108 typedef void type; 1109 }; 1110 1111 template <class A> 1112 void operator ()boost::lambda::ll::push_heap1113 operator()(A a, A b) const 1114 { ::std::push_heap(a, b); } 1115 1116 template <class A, class C> 1117 void operator ()boost::lambda::ll::push_heap1118 operator()(A a, A b, C c) const 1119 { ::std::push_heap(a, b, c); } 1120 1121 }; 1122 1123 // pop_heap --------------------------------- 1124 1125 struct pop_heap { 1126 1127 template <class Args> 1128 struct sig { 1129 typedef void type; 1130 }; 1131 1132 template <class A> 1133 void operator ()boost::lambda::ll::pop_heap1134 operator()(A a, A b) const 1135 { ::std::pop_heap(a, b); } 1136 1137 template <class A, class C> 1138 void operator ()boost::lambda::ll::pop_heap1139 operator()(A a, A b, C c) const 1140 { ::std::pop_heap(a, b, c); } 1141 1142 }; 1143 1144 1145 // make_heap --------------------------------- 1146 1147 struct make_heap { 1148 1149 template <class Args> 1150 struct sig { 1151 typedef void type; 1152 }; 1153 1154 template <class A> 1155 void operator ()boost::lambda::ll::make_heap1156 operator()(A a, A b) const 1157 { ::std::make_heap(a, b); } 1158 1159 template <class A, class C> 1160 void operator ()boost::lambda::ll::make_heap1161 operator()(A a, A b, C c) const 1162 { ::std::make_heap(a, b, c); } 1163 1164 }; 1165 1166 // sort_heap --------------------------------- 1167 1168 struct sort_heap { 1169 1170 template <class Args> 1171 struct sig { 1172 typedef void type; 1173 }; 1174 1175 template <class A> 1176 void operator ()boost::lambda::ll::sort_heap1177 operator()(A a, A b) const 1178 { ::std::sort_heap(a, b); } 1179 1180 template <class A, class C> 1181 void operator ()boost::lambda::ll::sort_heap1182 operator()(A a, A b, C c) const 1183 { ::std::sort_heap(a, b, c); } 1184 1185 }; 1186 1187 // min --------------------------------- 1188 1189 struct min { 1190 1191 template <class Args> 1192 struct sig { 1193 typedef typename boost::remove_const< 1194 typename boost::tuples::element<1, Args>::type 1195 >::type type; 1196 }; 1197 1198 template <class A> 1199 A operator ()boost::lambda::ll::min1200 operator()(const A& a, const A& b) const 1201 { return (::std::min)(a, b); } 1202 1203 template <class A, class C> 1204 A 1205 operator()(const A& a, const A& b, C c) const 1206 { return (::std::min)(a, b, c); } 1207 1208 }; 1209 1210 // max --------------------------------- 1211 1212 struct max { 1213 1214 template <class Args> 1215 struct sig { 1216 typedef typename boost::remove_const< 1217 typename boost::tuples::element<1, Args>::type 1218 >::type type; 1219 }; 1220 1221 template <class A> 1222 A operator ()boost::lambda::ll::max1223 operator()(const A& a, const A& b) const 1224 { return (::std::max)(a, b); } 1225 1226 template <class A, class C> 1227 A 1228 operator()(const A& a, const A& b, C c) const 1229 { return (::std::max)(a, b, c); } 1230 1231 }; 1232 1233 struct min_element { 1234 1235 template <class Args> 1236 struct sig { 1237 typedef typename boost::remove_const< 1238 typename boost::tuples::element<1, Args>::type 1239 >::type type; 1240 }; 1241 1242 template <class A> 1243 A operator ()boost::lambda::ll::min_element1244 operator()(A a, A b) const 1245 { return ::std::min_element(a, b); } 1246 1247 template <class A, class C> 1248 A 1249 operator()(A a, A b, C c) const 1250 { return ::std::min_element(a, b, c); } 1251 1252 }; 1253 1254 // max_element --------------------------------- 1255 1256 struct max_element { 1257 1258 template <class Args> 1259 struct sig { 1260 typedef typename boost::remove_const< 1261 typename boost::tuples::element<1, Args>::type 1262 >::type type; 1263 }; 1264 1265 template <class A> 1266 A operator ()boost::lambda::ll::max_element1267 operator()(A a, A b) const 1268 { return ::std::max_element(a, b); } 1269 1270 template <class A, class C> 1271 A 1272 operator()(A a, A b, C c) const 1273 { return ::std::max_element(a, b, c); } 1274 1275 }; 1276 1277 1278 // lexicographical_compare --------------------------------- 1279 1280 struct lexicographical_compare { 1281 1282 template <class Args> 1283 struct sig { 1284 typedef bool type; 1285 }; 1286 1287 template <class A, class C> 1288 bool operator ()boost::lambda::ll::lexicographical_compare1289 operator()(A a, A b, C c, C d) const 1290 { return ::std::lexicographical_compare(a, b, c, d); } 1291 1292 template <class A, class C, class E> 1293 bool operator ()boost::lambda::ll::lexicographical_compare1294 operator()(A a, A b, C c, C d, E e) const 1295 { return ::std::lexicographical_compare(a, b, c, d, e); } 1296 1297 }; 1298 1299 // next_permutation --------------------------------- 1300 1301 struct next_permutation { 1302 1303 template <class Args> 1304 struct sig { 1305 typedef bool type; 1306 }; 1307 1308 template <class A> 1309 bool operator ()boost::lambda::ll::next_permutation1310 operator()(A a, A b) const 1311 { return ::std::next_permutation(a, b); } 1312 1313 template <class A, class C > 1314 bool operator ()boost::lambda::ll::next_permutation1315 operator()(A a, A b, C c) const 1316 { return ::std::next_permutation(a, b, c); } 1317 1318 }; 1319 1320 // prev_permutation --------------------------------- 1321 1322 struct prev_permutation { 1323 1324 template <class Args> 1325 struct sig { 1326 typedef bool type; 1327 }; 1328 1329 template <class A> 1330 bool operator ()boost::lambda::ll::prev_permutation1331 operator()(A a, A b) const 1332 { return ::std::prev_permutation(a, b); } 1333 1334 template <class A, class C > 1335 bool operator ()boost::lambda::ll::prev_permutation1336 operator()(A a, A b, C c) const 1337 { return ::std::prev_permutation(a, b, c); } 1338 1339 }; 1340 1341 1342 1343 1344 1345 } // end of ll namespace 1346 1347 // There is no good way to call an overloaded member function in a 1348 // lambda expression. 1349 // The macro below defines a function object class for calling a 1350 // const_iterator returning member function of a container. 1351 1352 #define CALL_MEMBER(X) \ 1353 struct call_##X { \ 1354 template <class Args> \ 1355 struct sig { \ 1356 typedef typename boost::remove_const< \ 1357 typename boost::tuples::element<1, Args>::type \ 1358 >::type::const_iterator type; \ 1359 }; \ 1360 \ 1361 template<class T> \ 1362 typename T::const_iterator \ 1363 operator()(const T& t) const \ 1364 { \ 1365 return t.X(); \ 1366 } \ 1367 }; 1368 1369 // create call_begin and call_end classes 1370 CALL_MEMBER(begin) 1371 CALL_MEMBER(end) 1372 1373 #undef CALL_MEMBER 1374 1375 } // end of lambda namespace 1376 } // end of boost namespace 1377 1378 1379 1380 #endif 1381