| // -- algorithm.hpp -- Boost Lambda Library ----------------------------------- |
| // Copyright (C) 2002 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi) |
| // Copyright (C) 2002 Gary Powell (gwpowell@hotmail.com) |
| // |
| // Distributed under the Boost Software License, Version 1.0. (See |
| // accompanying file LICENSE_1_0.txt or copy at |
| // http://www.boost.org/LICENSE_1_0.txt) |
| // |
| // For more information, see http://www.boost.org |
| |
| #ifndef BOOST_LAMBDA_ALGORITHM_HPP |
| #define BOOST_LAMBDA_ALGORITHM_HPP |
| |
| #include "boost/lambda/core.hpp" |
| |
| #include <algorithm> |
| #include <iterator> // for iterator_traits |
| #include <utility> // for std::pair |
| |
| namespace boost { |
| namespace lambda { |
| |
| namespace ll { |
| |
| // for_each --------------------------------- |
| |
| struct for_each { |
| |
| template <class Args> |
| struct sig { |
| typedef typename boost::remove_const< |
| typename boost::tuples::element<3, Args>::type |
| >::type type; |
| }; |
| |
| template <class A, class C> |
| C |
| operator()(A a, A b, C c) const |
| { return ::std::for_each(a, b, c); } |
| }; |
| |
| // find --------------------------------- |
| |
| struct find { |
| |
| template <class Args> |
| struct sig { |
| typedef typename boost::remove_const< |
| typename boost::tuples::element<1, Args>::type |
| >::type type; |
| }; |
| |
| template <class A, class C> |
| A |
| operator()(A a, A b, const C& c) const |
| { return ::std::find(a, b, c); } |
| }; |
| |
| |
| // find_if --------------------------------- |
| |
| struct find_if { |
| |
| template <class Args> |
| struct sig { |
| typedef typename boost::remove_const< |
| typename boost::tuples::element<1, Args>::type |
| >::type type; |
| }; |
| |
| template <class A, class C> |
| A |
| operator()(A a, A b, C c) const |
| { return ::std::find_if(a, b, c); } |
| }; |
| |
| // find_end --------------------------------- |
| |
| struct find_end { |
| |
| template <class Args> |
| struct sig { |
| typedef typename boost::remove_const< |
| typename boost::tuples::element<1, Args>::type |
| >::type type; |
| }; |
| |
| template <class A, class C> |
| A |
| operator()(A a, A b, C c, C d) const |
| { return ::std::find_end(a, b, c, d); } |
| |
| template <class A, class C, class E> |
| A |
| operator()(A a, A b, C c, C d, E e) const |
| { return ::std::find_end(a, b, c, d, e); } |
| |
| }; |
| |
| // find_first_of --------------------------------- |
| |
| struct find_first_of { |
| |
| template <class Args> |
| struct sig { |
| typedef typename boost::remove_const< |
| typename boost::tuples::element<1, Args>::type |
| >::type type; |
| }; |
| |
| template <class A, class C> |
| A |
| operator()(A a, A b, C c, C d) const |
| { return ::std::find_first_of(a, b, c, d); } |
| |
| template <class A, class C, class E> |
| A |
| operator()(A a, A b, C c, C d, E e) const |
| { return ::std::find_first_of(a, b, c, d, e); } |
| |
| }; |
| |
| // adjacent_find --------------------------------- |
| |
| struct adjacent_find { |
| |
| template <class Args> |
| struct sig { |
| typedef typename boost::remove_const< |
| typename boost::tuples::element<1, Args>::type |
| >::type type; |
| }; |
| |
| template <class A> |
| A |
| operator()(A a, A b) const |
| { return ::std::adjacent_find(a, b); } |
| |
| template <class A, class C> |
| A |
| operator()(A a, A b, C c) const |
| { return ::std::adjacent_find(a, b, c); } |
| |
| }; |
| |
| // count --------------------------------- |
| |
| struct count { |
| |
| template <class Args> |
| struct sig { |
| typedef typename ::std::iterator_traits< |
| typename boost::remove_const< |
| typename boost::tuples::element<1, Args>::type |
| >::type |
| >::difference_type type; |
| }; |
| |
| template <class A, class C > |
| typename ::std::iterator_traits<A>::difference_type |
| operator()(A a, A b, const C& c) const |
| { return ::std::count(a, b, c); } |
| }; |
| |
| // count_if --------------------------------- |
| |
| struct count_if { |
| |
| template <class Args> |
| struct sig { |
| typedef typename ::std::iterator_traits< |
| typename boost::remove_const< |
| typename boost::tuples::element<1, Args>::type |
| >::type |
| >::difference_type type; |
| }; |
| |
| template <class A, class C > |
| typename ::std::iterator_traits<A>::difference_type |
| operator()(A a, A b, C c) const |
| { return ::std::count_if(a, b, c); } |
| }; |
| |
| |
| // mismatch --------------------------------- |
| |
| struct mismatch { |
| |
| template <class Args> |
| struct sig { |
| typedef typename boost::remove_const< |
| typename boost::tuples::element<1, Args>::type |
| >::type element1_type; |
| |
| typedef typename boost::remove_const< |
| typename boost::tuples::element<3, Args>::type |
| >::type element2_type; |
| |
| typedef ::std::pair< element1_type, element2_type > type; |
| }; |
| |
| template <class A, class C > |
| ::std::pair<A,C> |
| operator()(A a, A b, C c) const |
| { return ::std::mismatch(a, b, c); } |
| |
| template <class A, class C, class D> |
| ::std::pair<A,C> |
| operator()(A a, A b, C c, D d) const |
| { return ::std::mismatch(a, b, c, d); } |
| |
| }; |
| |
| // equal --------------------------------- |
| |
| struct equal { |
| |
| template <class Args> |
| struct sig { |
| typedef bool type; |
| }; |
| |
| template <class A, class C > |
| bool |
| operator()(A a, A b, C c) const |
| { return ::std::equal(a, b, c); } |
| |
| template <class A, class C, class D> |
| bool |
| operator()(A a, A b, C c, D d) const |
| { return ::std::equal(a, b, c, d); } |
| |
| }; |
| |
| // search -------------------------------- |
| |
| struct search { |
| |
| template <class Args> |
| struct sig { |
| typedef typename boost::remove_const< |
| typename boost::tuples::element<1, Args>::type |
| >::type type; |
| }; |
| |
| template <class A, class C> |
| A |
| operator()(A a, A b, C c, C d) const |
| { return std::search(a, b, c, d);} |
| |
| template <class A, class C, class E> |
| A |
| operator()(A a, A b, C c, C d, E e) const |
| { return std::search(a, b, c, d, e);} |
| |
| }; |
| |
| // copy --------------------------------- |
| |
| struct copy { |
| |
| template <class Args> |
| struct sig { |
| typedef typename boost::remove_const< |
| typename boost::tuples::element<3, Args>::type |
| >::type type; |
| }; |
| |
| template <class A, class C> |
| C |
| operator()(A a, A b, C c) const |
| { return ::std::copy(a, b, c); } |
| |
| }; |
| |
| // copy_backward --------------------------------- |
| |
| struct copy_backward { |
| |
| template <class Args> |
| struct sig { |
| typedef typename boost::remove_const< |
| typename boost::tuples::element<3, Args>::type |
| >::type type; |
| }; |
| |
| template <class A, class C> |
| C |
| operator()(A a, A b, C c) const |
| { return ::std::copy_backward(a, b, c); } |
| |
| }; |
| |
| // swap --------------------------------- |
| |
| struct swap { |
| |
| template <class Args> |
| struct sig { |
| typedef void type; |
| }; |
| |
| template <class A> |
| void |
| operator()(A a, A b) const |
| { ::std::swap(a, b); } |
| |
| }; |
| |
| // swap_ranges --------------------------------- |
| |
| struct swap_ranges { |
| |
| template <class Args> |
| struct sig { |
| typedef typename boost::remove_const< |
| typename boost::tuples::element<3, Args>::type |
| >::type type; |
| }; |
| |
| template <class A, class C> |
| C |
| operator()(A a, A b, C c) const |
| { return ::std::swap_ranges(a, b, c); } |
| |
| }; |
| |
| // iter_swap --------------------------------- |
| |
| struct iter_swap { |
| |
| template <class Args> |
| struct sig { |
| typedef void type; |
| }; |
| |
| template <class A> |
| void |
| operator()(A a, A b) const |
| { ::std::iter_swap(a, b); } |
| |
| }; |
| |
| |
| // transform -------------------------------- |
| |
| struct transform { |
| |
| template <class Args> |
| struct sig { |
| typedef typename boost::remove_const< |
| typename boost::tuples::element< |
| boost::tuples::length<Args>::value - 2, |
| Args |
| >::type |
| >::type type; |
| }; |
| |
| template <class A, class C, class D> |
| C |
| operator()(A a, A b, C c, D d) const |
| { return std::transform(a, b, c, d);} |
| |
| template <class A, class C, class D, class E> |
| D |
| operator()(A a, A b, C c, D d, E e) const |
| { return std::transform(a, b, c, d, e);} |
| |
| }; |
| |
| // replace --------------------------------- |
| |
| struct replace { |
| |
| template <class Args> |
| struct sig { |
| typedef void type; |
| }; |
| |
| template <class A, class C> |
| void |
| operator()(A a, A b, const C& c, const C& d) const |
| { ::std::replace(a, b, c, d); } |
| |
| }; |
| |
| // replace_if --------------------------------- |
| |
| struct replace_if { |
| |
| template <class Args> |
| struct sig { |
| typedef void type; |
| }; |
| |
| template <class A, class C, class D> |
| void |
| operator()(A a, A b, C c, const D& d) const |
| { ::std::replace_if(a, b, c, d); } |
| |
| }; |
| |
| // replace_copy --------------------------------- |
| |
| struct replace_copy { |
| |
| template <class Args> |
| struct sig { |
| typedef typename boost::remove_const< |
| typename boost::tuples::element<3, Args>::type |
| >::type type; |
| }; |
| |
| template <class A, class C, class D> |
| C |
| operator()(A a, A b, C c, const D& d, const D& e) const |
| { return ::std::replace_copy(a, b, c, d, e); } |
| |
| }; |
| |
| // replace_copy_if --------------------------------- |
| |
| struct replace_copy_if { |
| |
| template <class Args> |
| struct sig { |
| typedef typename boost::remove_const< |
| typename boost::tuples::element<3, Args>::type |
| >::type type; |
| }; |
| |
| template <class A, class C, class D, class E> |
| C |
| operator()(A a, A b, C c, D d, const E& e) const |
| { return ::std::replace_copy_if(a, b, c, d, e); } |
| |
| }; |
| |
| // fill --------------------------------- |
| |
| struct fill { |
| |
| template <class Args> |
| struct sig { |
| typedef void type; |
| }; |
| |
| template <class A, class C> |
| void |
| operator()(A a, A b, const C& c) const |
| { ::std::fill(a, b, c); } |
| |
| }; |
| |
| // fill_n --------------------------------- |
| |
| struct fill_n { |
| |
| template <class Args> |
| struct sig { |
| typedef void type; |
| }; |
| |
| template <class A, class B, class C> |
| void |
| operator()(A a, B b, const C& c) const |
| { ::std::fill_n(a, b, c); } |
| |
| }; |
| |
| // generate --------------------------------- |
| |
| struct generate { |
| |
| template <class Args> |
| struct sig { |
| typedef void type; |
| }; |
| |
| template <class A, class C> |
| void |
| operator()(A a, A b, C c) const |
| { ::std::generate(a, b, c); } |
| |
| }; |
| |
| // generate_n --------------------------------- |
| |
| struct generate_n { |
| |
| template <class Args> |
| struct sig { |
| typedef void type; |
| }; |
| |
| template <class A, class B, class C> |
| void |
| operator()(A a, B b, C c) const |
| { ::std::generate_n(a, b, c); } |
| |
| }; |
| |
| // remove --------------------------------- |
| |
| struct remove { |
| |
| template <class Args> |
| struct sig { |
| typedef typename boost::remove_const< |
| typename boost::tuples::element<1, Args>::type |
| >::type type; |
| }; |
| |
| template <class A, class C > |
| A |
| operator()(A a, A b, const C& c) const |
| { return ::std::remove(a, b, c); } |
| }; |
| |
| // remove_if --------------------------------- |
| |
| struct remove_if { |
| |
| template <class Args> |
| struct sig { |
| typedef typename boost::remove_const< |
| typename boost::tuples::element<1, Args>::type |
| >::type type; |
| }; |
| |
| template <class A, class C > |
| A |
| operator()(A a, A b, C c) const |
| { return ::std::remove_if(a, b, c); } |
| }; |
| |
| // remove_copy --------------------------------- |
| |
| struct remove_copy { |
| |
| template <class Args> |
| struct sig { |
| typedef typename boost::remove_const< |
| typename boost::tuples::element<3, Args>::type |
| >::type type; |
| }; |
| |
| template <class A, class C, class D > |
| C |
| operator()(A a, A b, C c, const D& d) const |
| { return ::std::remove_copy(a, b, c, d); } |
| }; |
| |
| // remove_copy_if --------------------------------- |
| |
| struct remove_copy_if { |
| |
| template <class Args> |
| struct sig { |
| typedef typename boost::remove_const< |
| typename boost::tuples::element<3, Args>::type |
| >::type type; |
| }; |
| |
| template <class A, class C, class D > |
| C |
| operator()(A a, A b, C c, D d) const |
| { return ::std::remove_copy_if(a, b, c, d); } |
| }; |
| |
| // unique --------------------------------- |
| |
| struct unique { |
| |
| template <class Args> |
| struct sig { |
| typedef typename boost::remove_const< |
| typename boost::tuples::element<1, Args>::type |
| >::type type; |
| }; |
| |
| template <class A> |
| A |
| operator()(A a, A b) const |
| { return ::std::unique(a, b); } |
| |
| template <class A, class C> |
| A |
| operator()(A a, A b, C c) const |
| { return ::std::unique(a, b, c); } |
| |
| }; |
| |
| // unique_copy --------------------------------- |
| |
| struct unique_copy { |
| |
| template <class Args> |
| struct sig { |
| typedef typename boost::remove_const< |
| typename boost::tuples::element<3, Args>::type |
| >::type type; |
| }; |
| |
| template <class A, class C > |
| C |
| operator()(A a, A b, C c) const |
| { return ::std::unique_copy(a, b, c); } |
| |
| template <class A, class C, class D> |
| C |
| operator()(A a, A b, C c, D d) const |
| { return ::std::unique_copy(a, b, c, d); } |
| |
| }; |
| |
| // reverse --------------------------------- |
| |
| struct reverse { |
| |
| template <class Args> |
| struct sig { |
| typedef void type; |
| }; |
| |
| template <class A> |
| void |
| operator()(A a, A b) const |
| { ::std::reverse(a, b); } |
| |
| }; |
| |
| // reverse_copy --------------------------------- |
| |
| struct reverse_copy { |
| |
| template <class Args> |
| struct sig { |
| typedef typename boost::remove_const< |
| typename boost::tuples::element<3, Args>::type |
| >::type type; |
| }; |
| |
| template <class A, class C > |
| C |
| operator()(A a, A b, C c) const |
| { return ::std::reverse_copy(a, b, c); } |
| |
| }; |
| |
| // rotate --------------------------------- |
| |
| struct rotate { |
| |
| template <class Args> |
| struct sig { |
| typedef void type; |
| }; |
| |
| template <class A> |
| void |
| operator()(A a, A b, A c) const |
| { ::std::rotate(a, b, c); } |
| |
| }; |
| |
| // rotate_copy --------------------------------- |
| |
| struct rotate_copy { |
| |
| template <class Args> |
| struct sig { |
| typedef typename boost::remove_const< |
| typename boost::tuples::element<3, Args>::type |
| >::type type; |
| }; |
| |
| template <class A, class D> |
| D |
| operator()(A a, A b, A c, D d) const |
| { return ::std::rotate_copy(a, b, c, d); } |
| |
| }; |
| |
| // random_shuffle --------------------------------- |
| |
| struct random_shuffle { |
| |
| template <class Args> |
| struct sig { |
| typedef void type; |
| }; |
| |
| template <class A> |
| void |
| operator()(A a, A b) const |
| { ::std::random_shuffle(a, b); } |
| |
| template <class A, class C> |
| void |
| operator()(A a, A b, const C& c) const |
| { ::std::random_shuffle(a, b, c); } |
| |
| }; |
| |
| |
| // partition --------------------------------- |
| |
| struct partition { |
| |
| template <class Args> |
| struct sig { |
| typedef typename boost::remove_const< |
| typename boost::tuples::element<1, Args>::type |
| >::type type; |
| }; |
| |
| template <class A, class C> |
| A |
| operator()(A a, A b, C c) const |
| { return ::std::partition(a, b, c); } |
| |
| }; |
| |
| // stable_partition --------------------------------- |
| |
| struct stable_partition { |
| |
| template <class Args> |
| struct sig { |
| typedef typename boost::remove_const< |
| typename boost::tuples::element<1, Args>::type |
| >::type type; |
| }; |
| |
| template <class A, class C> |
| A |
| operator()(A a, A b, C c) const |
| { return ::std::stable_partition(a, b, c); } |
| |
| }; |
| |
| // sort --------------------------------- |
| |
| struct sort { |
| |
| template <class Args> |
| struct sig { |
| typedef void type; |
| }; |
| |
| template <class A> |
| void |
| operator()(A a, A b) const |
| { ::std::sort(a, b); } |
| |
| template <class A, class C> |
| void |
| operator()(A a, A b, C c) const |
| { ::std::sort(a, b, c); } |
| |
| }; |
| |
| // stable_sort --------------------------------- |
| |
| struct stable_sort { |
| |
| template <class Args> |
| struct sig { |
| typedef void type; |
| }; |
| |
| template <class A> |
| void |
| operator()(A a, A b) const |
| { ::std::stable_sort(a, b); } |
| |
| template <class A, class C> |
| void |
| operator()(A a, A b, C c) const |
| { ::std::stable_sort(a, b, c); } |
| |
| }; |
| |
| // partial_sort --------------------------------- |
| |
| struct partial_sort { |
| |
| template <class Args> |
| struct sig { |
| typedef void type; |
| }; |
| |
| template <class A> |
| void |
| operator()(A a, A b, A c) const |
| { ::std::partial_sort(a, b, c); } |
| |
| template <class A, class D> |
| void |
| operator()(A a, A b, A c, D d) const |
| { ::std::partial_sort(a, b, c, d); } |
| |
| }; |
| |
| // partial_sort_copy --------------------------------- |
| |
| struct partial_sort_copy { |
| |
| template <class Args> |
| struct sig { |
| typedef typename boost::remove_const< |
| typename boost::tuples::element<3, Args>::type |
| >::type type; |
| }; |
| |
| template <class A, class C> |
| C |
| operator()(A a, A b, C c, C d) const |
| { return ::std::partial_sort_copy(a, b, c, d); } |
| |
| template <class A, class C, class E > |
| C |
| operator()(A a, A b, C c, C d, E e) const |
| { return ::std::partial_sort_copy(a, b, c, d, e); } |
| }; |
| |
| // nth_element --------------------------------- |
| |
| struct nth_element { |
| |
| template <class Args> |
| struct sig { |
| typedef void type; |
| }; |
| |
| template <class A> |
| void |
| operator()(A a, A b, A c) const |
| { ::std::nth_element(a, b, c); } |
| |
| template <class A, class D> |
| void |
| operator()(A a, A b, A c, D d) const |
| { ::std::nth_element(a, b, c, d); } |
| |
| }; |
| |
| // lower_bound --------------------------------- |
| |
| struct lower_bound { |
| |
| template <class Args> |
| struct sig { |
| typedef typename boost::remove_const< |
| typename boost::tuples::element<1, Args>::type |
| >::type type; |
| }; |
| |
| template <class A, class C> |
| A |
| operator()(A a, A b, const C& c) const |
| { return ::std::lower_bound(a, b, c); } |
| |
| template <class A, class C, class D> |
| A |
| operator()(A a, A b, const C& c, D d) const |
| { return ::std::lower_bound(a, b, c, d); } |
| |
| }; |
| |
| // upper_bound --------------------------------- |
| |
| struct upper_bound { |
| |
| template <class Args> |
| struct sig { |
| typedef typename boost::remove_const< |
| typename boost::tuples::element<1, Args>::type |
| >::type type; |
| }; |
| |
| template <class A, class C> |
| A |
| operator()(A a, A b, const C& c) const |
| { return ::std::upper_bound(a, b, c); } |
| |
| template <class A, class C, class D> |
| A |
| operator()(A a, A b, const C& c, D d) const |
| { return ::std::upper_bound(a, b, c, d); } |
| |
| }; |
| |
| // equal_range --------------------------------- |
| |
| struct equal_range { |
| |
| template <class Args> |
| struct sig { |
| typedef typename boost::remove_const< |
| typename boost::tuples::element<1, Args>::type |
| >::type element_type; |
| |
| typedef ::std::pair< element_type, element_type > type; |
| }; |
| |
| template <class A, class C> |
| ::std::pair<A,A> |
| operator()(A a, A b, const C& c) const |
| { return ::std::equal_range(a, b, c); } |
| |
| template <class A, class C, class D> |
| ::std::pair<A,A> |
| operator()(A a, A b, const C& c, D d) const |
| { return ::std::equal_range(a, b, c, d); } |
| |
| }; |
| |
| // binary_search --------------------------------- |
| |
| struct binary_search { |
| |
| template <class Args> |
| struct sig { |
| typedef bool type; |
| }; |
| |
| template <class A, class C > |
| bool |
| operator()(A a, A b, const C& c) const |
| { return ::std::binary_search(a, b, c); } |
| |
| template <class A, class C, class D> |
| bool |
| operator()(A a, A b, const C& c, D d) const |
| { return ::std::binary_search(a, b, c, d); } |
| |
| }; |
| |
| // merge -------------------------------- |
| |
| struct merge { |
| |
| template <class Args> |
| struct sig { |
| typedef typename boost::remove_const< |
| typename boost::tuples::element<5, Args>::type |
| >::type type; |
| }; |
| |
| template <class A, class C, class E> |
| E |
| operator()(A a, A b, C c, C d, E e) const |
| { return std::merge(a, b, c, d, e);} |
| |
| template <class A, class C, class E, class F> |
| E |
| operator()(A a, A b, C c, C d, E e, F f) const |
| { return std::merge(a, b, c, d, e, f);} |
| |
| }; |
| |
| // inplace_merge --------------------------------- |
| |
| struct inplace_merge { |
| |
| template <class Args> |
| struct sig { |
| typedef void type; |
| }; |
| |
| template <class A> |
| void |
| operator()(A a, A b, A c) const |
| { ::std::inplace_merge(a, b, c); } |
| |
| template <class A, class D> |
| void |
| operator()(A a, A b, A c, D d) const |
| { ::std::inplace_merge(a, b, c, d); } |
| |
| }; |
| |
| // includes --------------------------------- |
| |
| struct includes { |
| |
| template <class Args> |
| struct sig { |
| typedef bool type; |
| }; |
| |
| template <class A, class C> |
| bool |
| operator()(A a, A b, C c, C d) const |
| { return ::std::includes(a, b, c, d); } |
| |
| template <class A, class C, class E> |
| bool |
| operator()(A a, A b, C c, C d, E e) const |
| { return ::std::includes(a, b, c, d, e); } |
| |
| }; |
| |
| // set_union -------------------------------- |
| |
| struct set_union { |
| |
| template <class Args> |
| struct sig { |
| typedef typename boost::remove_const< |
| typename boost::tuples::element<5, Args>::type |
| >::type type; |
| }; |
| |
| template <class A, class C, class E> |
| E |
| operator()(A a, A b, C c, C d, E e) const |
| { return std::set_union(a, b, c, d, e);} |
| |
| template <class A, class C, class E, class F> |
| E |
| operator()(A a, A b, C c, C d, E e, F f) const |
| { return std::set_union(a, b, c, d, e, f);} |
| |
| }; |
| |
| // set_intersection -------------------------------- |
| |
| struct set_intersection { |
| |
| template <class Args> |
| struct sig { |
| typedef typename boost::remove_const< |
| typename boost::tuples::element<5, Args>::type |
| >::type type; |
| }; |
| |
| template <class A, class C, class E> |
| E |
| operator()(A a, A b, C c, C d, E e) const |
| { return std::set_intersection(a, b, c, d, e);} |
| |
| template <class A, class C, class E, class F> |
| E |
| operator()(A a, A b, C c, C d, E e, F f) const |
| { return std::set_intersection(a, b, c, d, e, f);} |
| |
| }; |
| |
| // set_difference -------------------------------- |
| |
| struct set_difference { |
| |
| template <class Args> |
| struct sig { |
| typedef typename boost::remove_const< |
| typename boost::tuples::element<5, Args>::type |
| >::type type; |
| }; |
| |
| template <class A, class C, class E> |
| E |
| operator()(A a, A b, C c, C d, E e) const |
| { return std::set_difference(a, b, c, d, e);} |
| |
| template <class A, class C, class E, class F> |
| E |
| operator()(A a, A b, C c, C d, E e, F f) const |
| { return std::set_difference(a, b, c, d, e, f);} |
| |
| }; |
| |
| |
| // set_symmetric_difference -------------------------------- |
| |
| struct set_symmetric_difference { |
| |
| template <class Args> |
| struct sig { |
| typedef typename boost::remove_const< |
| typename boost::tuples::element<5, Args>::type |
| >::type type; |
| }; |
| |
| template <class A, class C, class E> |
| E |
| operator()(A a, A b, C c, C d, E e) const |
| { return std::set_symmetric_difference(a, b, c, d, e);} |
| |
| template <class A, class C, class E, class F> |
| E |
| operator()(A a, A b, C c, C d, E e, F f) const |
| { return std::set_symmetric_difference(a, b, c, d, e, f);} |
| |
| }; |
| |
| // push_heap --------------------------------- |
| |
| struct push_heap { |
| |
| template <class Args> |
| struct sig { |
| typedef void type; |
| }; |
| |
| template <class A> |
| void |
| operator()(A a, A b) const |
| { ::std::push_heap(a, b); } |
| |
| template <class A, class C> |
| void |
| operator()(A a, A b, C c) const |
| { ::std::push_heap(a, b, c); } |
| |
| }; |
| |
| // pop_heap --------------------------------- |
| |
| struct pop_heap { |
| |
| template <class Args> |
| struct sig { |
| typedef void type; |
| }; |
| |
| template <class A> |
| void |
| operator()(A a, A b) const |
| { ::std::pop_heap(a, b); } |
| |
| template <class A, class C> |
| void |
| operator()(A a, A b, C c) const |
| { ::std::pop_heap(a, b, c); } |
| |
| }; |
| |
| |
| // make_heap --------------------------------- |
| |
| struct make_heap { |
| |
| template <class Args> |
| struct sig { |
| typedef void type; |
| }; |
| |
| template <class A> |
| void |
| operator()(A a, A b) const |
| { ::std::make_heap(a, b); } |
| |
| template <class A, class C> |
| void |
| operator()(A a, A b, C c) const |
| { ::std::make_heap(a, b, c); } |
| |
| }; |
| |
| // sort_heap --------------------------------- |
| |
| struct sort_heap { |
| |
| template <class Args> |
| struct sig { |
| typedef void type; |
| }; |
| |
| template <class A> |
| void |
| operator()(A a, A b) const |
| { ::std::sort_heap(a, b); } |
| |
| template <class A, class C> |
| void |
| operator()(A a, A b, C c) const |
| { ::std::sort_heap(a, b, c); } |
| |
| }; |
| |
| // min --------------------------------- |
| |
| struct min { |
| |
| template <class Args> |
| struct sig { |
| typedef typename boost::remove_const< |
| typename boost::tuples::element<1, Args>::type |
| >::type type; |
| }; |
| |
| template <class A> |
| A |
| operator()(const A& a, const A& b) const |
| { return (::std::min)(a, b); } |
| |
| template <class A, class C> |
| A |
| operator()(const A& a, const A& b, C c) const |
| { return (::std::min)(a, b, c); } |
| |
| }; |
| |
| // max --------------------------------- |
| |
| struct max { |
| |
| template <class Args> |
| struct sig { |
| typedef typename boost::remove_const< |
| typename boost::tuples::element<1, Args>::type |
| >::type type; |
| }; |
| |
| template <class A> |
| A |
| operator()(const A& a, const A& b) const |
| { return (::std::max)(a, b); } |
| |
| template <class A, class C> |
| A |
| operator()(const A& a, const A& b, C c) const |
| { return (::std::max)(a, b, c); } |
| |
| }; |
| |
| struct min_element { |
| |
| template <class Args> |
| struct sig { |
| typedef typename boost::remove_const< |
| typename boost::tuples::element<1, Args>::type |
| >::type type; |
| }; |
| |
| template <class A> |
| A |
| operator()(A a, A b) const |
| { return ::std::min_element(a, b); } |
| |
| template <class A, class C> |
| A |
| operator()(A a, A b, C c) const |
| { return ::std::min_element(a, b, c); } |
| |
| }; |
| |
| // max_element --------------------------------- |
| |
| struct max_element { |
| |
| template <class Args> |
| struct sig { |
| typedef typename boost::remove_const< |
| typename boost::tuples::element<1, Args>::type |
| >::type type; |
| }; |
| |
| template <class A> |
| A |
| operator()(A a, A b) const |
| { return ::std::max_element(a, b); } |
| |
| template <class A, class C> |
| A |
| operator()(A a, A b, C c) const |
| { return ::std::max_element(a, b, c); } |
| |
| }; |
| |
| |
| // lexicographical_compare --------------------------------- |
| |
| struct lexicographical_compare { |
| |
| template <class Args> |
| struct sig { |
| typedef bool type; |
| }; |
| |
| template <class A, class C> |
| bool |
| operator()(A a, A b, C c, C d) const |
| { return ::std::lexicographical_compare(a, b, c, d); } |
| |
| template <class A, class C, class E> |
| bool |
| operator()(A a, A b, C c, C d, E e) const |
| { return ::std::lexicographical_compare(a, b, c, d, e); } |
| |
| }; |
| |
| // next_permutation --------------------------------- |
| |
| struct next_permutation { |
| |
| template <class Args> |
| struct sig { |
| typedef bool type; |
| }; |
| |
| template <class A> |
| bool |
| operator()(A a, A b) const |
| { return ::std::next_permutation(a, b); } |
| |
| template <class A, class C > |
| bool |
| operator()(A a, A b, C c) const |
| { return ::std::next_permutation(a, b, c); } |
| |
| }; |
| |
| // prev_permutation --------------------------------- |
| |
| struct prev_permutation { |
| |
| template <class Args> |
| struct sig { |
| typedef bool type; |
| }; |
| |
| template <class A> |
| bool |
| operator()(A a, A b) const |
| { return ::std::prev_permutation(a, b); } |
| |
| template <class A, class C > |
| bool |
| operator()(A a, A b, C c) const |
| { return ::std::prev_permutation(a, b, c); } |
| |
| }; |
| |
| |
| |
| |
| |
| } // end of ll namespace |
| |
| // There is no good way to call an overloaded member function in a |
| // lambda expression. |
| // The macro below defines a function object class for calling a |
| // const_iterator returning member function of a container. |
| |
| #define CALL_MEMBER(X) \ |
| struct call_##X { \ |
| template <class Args> \ |
| struct sig { \ |
| typedef typename boost::remove_const< \ |
| typename boost::tuples::element<1, Args>::type \ |
| >::type::const_iterator type; \ |
| }; \ |
| \ |
| template<class T> \ |
| typename T::const_iterator \ |
| operator()(const T& t) const \ |
| { \ |
| return t.X(); \ |
| } \ |
| }; |
| |
| // create call_begin and call_end classes |
| CALL_MEMBER(begin) |
| CALL_MEMBER(end) |
| |
| #undef CALL_MEMBER |
| |
| } // end of lambda namespace |
| } // end of boost namespace |
| |
| |
| |
| #endif |