--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ossrv_pub/boost_apis/boost/lambda/algorithm.hpp Tue Feb 02 02:01:42 2010 +0200
@@ -0,0 +1,1377 @@
+// -- algorithm.hpp -- Boost Lambda Library -----------------------------------
+// Copyright (C) 2002 Jaakko Järvi (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