1378 lines
28 KiB
C++
1378 lines
28 KiB
C++
// -- 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
|