You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and dots ('.'), can be up to 35 characters long. Letters must be lowercase.
1377 lines
27 KiB
1377 lines
27 KiB
// -- 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
|
|
|