// Copyright 2005 Daniel Wallin. | |
// Copyright 2005 Joel de Guzman. | |
// Copyright 2005 Dan Marsden. | |
// | |
// Use, modification and distribution is subject to 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) | |
// | |
// Modeled after range_ex, Copyright 2004 Eric Niebler | |
#ifndef PHOENIX_ALGORITHM_TRANSFORMATION_HPP | |
#define PHOENIX_ALGORITHM_TRANSFORMATION_HPP | |
#include <algorithm> | |
#include <numeric> | |
#include <boost/spirit/home/phoenix/stl/algorithm/detail/has_sort.hpp> | |
#include <boost/spirit/home/phoenix/stl/algorithm/detail/has_remove.hpp> | |
#include <boost/spirit/home/phoenix/stl/algorithm/detail/has_remove_if.hpp> | |
#include <boost/spirit/home/phoenix/stl/algorithm/detail/has_unique.hpp> | |
#include <boost/spirit/home/phoenix/stl/algorithm/detail/has_reverse.hpp> | |
#include <boost/spirit/home/phoenix/stl/algorithm/detail/has_sort.hpp> | |
#include <boost/spirit/home/phoenix/stl/algorithm/detail/begin.hpp> | |
#include <boost/spirit/home/phoenix/stl/algorithm/detail/end.hpp> | |
#include <boost/spirit/home/phoenix/stl/algorithm/detail/decay_array.hpp> | |
#include <boost/spirit/home/phoenix/function/function.hpp> | |
#include <boost/range/result_iterator.hpp> | |
#include <boost/range/difference_type.hpp> | |
#include <boost/mpl/if.hpp> | |
#include <boost/type_traits/is_void.hpp> | |
namespace boost { namespace phoenix { namespace impl | |
{ | |
struct swap | |
{ | |
template <class A, class B> | |
struct result | |
{ | |
typedef void type; | |
}; | |
template <class A, class B> | |
void operator()(A& a, B& b) const | |
{ | |
using std::swap; | |
swap(a, b); | |
} | |
}; | |
struct copy | |
{ | |
template<class R, class I> | |
struct result | |
: detail::decay_array<I> | |
{}; | |
template<class R, class I> | |
typename result<R,I>::type | |
operator()(R& r, I i) const | |
{ | |
return std::copy(detail::begin_(r), detail::end_(r), i); | |
} | |
}; | |
struct copy_backward | |
{ | |
template<class R, class I> | |
struct result | |
{ | |
typedef I type; | |
}; | |
template<class R, class I> | |
I operator()(R& r, I i) const | |
{ | |
return std::copy_backward(detail::begin_(r), detail::end_(r), i); | |
} | |
}; | |
struct transform | |
{ | |
template<class R, class OutorI1, class ForOut, class BinF = void> | |
struct result | |
: detail::decay_array< | |
typename mpl::if_<is_void<BinF>, OutorI1, ForOut>::type> | |
{ | |
}; | |
template<class R, class O, class F> | |
typename result<R,O,F>::type | |
operator()(R& r, O o, F f) const | |
{ | |
return std::transform(detail::begin_(r), detail::end_(r), o, f); | |
} | |
template<class R, class I, class O, class F> | |
typename result<R,I,O,F>::type | |
operator()(R& r, I i, O o, F f) const | |
{ | |
return std::transform(detail::begin_(r), detail::end_(r), i, o, f); | |
} | |
}; | |
struct replace | |
{ | |
template<class R, class T, class T2> | |
struct result | |
{ | |
typedef void type; | |
}; | |
template<class R, class T> | |
void operator()(R& r, T const& what, T const& with) const | |
{ | |
std::replace(detail::begin_(r), detail::end_(r), what, with); | |
} | |
}; | |
struct replace_if | |
{ | |
template<class R, class P, class T> | |
struct result | |
{ | |
typedef void type; | |
}; | |
template<class R, class P, class T> | |
void operator()(R& r, P p, T const& with) const | |
{ | |
std::replace_if(detail::begin_(r), detail::end_(r), p, with); | |
} | |
}; | |
struct replace_copy | |
{ | |
template<class R, class O, class T, class T2> | |
struct result | |
: detail::decay_array<O> | |
{}; | |
template<class R, class O, class T> | |
typename result<R,O,T,T>::type | |
operator()(R& r, O o, T const& what, T const& with) const | |
{ | |
return std::replace_copy(detail::begin_(r), detail::end_(r), o, what, with); | |
} | |
}; | |
struct replace_copy_if | |
{ | |
template<class R, class O, class P, class T> | |
struct result | |
: detail::decay_array<O> | |
{}; | |
template<class R, class O, class P, class T> | |
typename result<R,O,P,T>::type | |
operator()(R& r, O o, P p, T const& with) const | |
{ | |
return std::replace_copy_if(detail::begin_(r), detail::end_(r), o, p, with); | |
} | |
}; | |
struct fill | |
{ | |
template<class R, class T> | |
struct result | |
{ | |
typedef void type; | |
}; | |
template<class R, class T> | |
void operator()(R& r, T const& x) const | |
{ | |
std::fill(detail::begin_(r), detail::end_(r), x); | |
} | |
}; | |
struct fill_n | |
{ | |
template<class R, class N, class T> | |
struct result | |
{ | |
typedef void type; | |
}; | |
template<class R, class N, class T> | |
void operator()(R& r, N n, T const& x) const | |
{ | |
std::fill_n(detail::begin_(r), n, x); | |
} | |
}; | |
struct generate | |
{ | |
template<class R, class G> | |
struct result | |
{ | |
typedef void type; | |
}; | |
template<class R, class G> | |
void operator()(R& r, G g) const | |
{ | |
std::generate(detail::begin_(r), detail::end_(r), g); | |
} | |
}; | |
struct generate_n | |
{ | |
template<class R, class N, class G> | |
struct result | |
{ | |
typedef void type; | |
}; | |
template<class R, class N, class G> | |
void operator()(R& r, N n, G g) const | |
{ | |
std::generate_n(detail::begin_(r), n, g); | |
} | |
}; | |
struct remove | |
{ | |
template<class R, class T> | |
struct result : range_result_iterator<R> | |
{ | |
}; | |
template<class R, class T> | |
typename result<R, T>::type execute(R& r, T const& x, mpl::true_) const | |
{ | |
r.remove(x); | |
return detail::end_(r); | |
} | |
template<class R, class T> | |
typename result<R, T>::type execute(R& r, T const& x, mpl::false_) const | |
{ | |
return std::remove(detail::begin_(r), detail::end_(r), x); | |
} | |
template<class R, class T> | |
typename result<R, T>::type operator()(R& r, T const& x) const | |
{ | |
return execute(r, x, has_remove<R>()); | |
} | |
}; | |
struct remove_if | |
{ | |
template<class R, class P> | |
struct result : range_result_iterator<R> | |
{ | |
}; | |
template<class R, class P> | |
typename result<R, P>::type execute(R& r, P p, mpl::true_) const | |
{ | |
r.remove_if(p); | |
return detail::end_(r); | |
} | |
template<class R, class P> | |
typename result<R, P>::type execute(R& r, P p, mpl::false_) const | |
{ | |
return std::remove_if(detail::begin_(r), detail::end_(r), p); | |
} | |
template<class R, class P> | |
typename result<R, P>::type operator()(R& r, P p) const | |
{ | |
return execute(r, p, has_remove_if<R>()); | |
} | |
}; | |
struct remove_copy | |
{ | |
template<class R, class O, class T> | |
struct result | |
: detail::decay_array<O> | |
{}; | |
template<class R, class O, class T> | |
typename result<R,O,T>::type | |
operator()(R& r, O o, T const& x) const | |
{ | |
return std::remove_copy(detail::begin_(r), detail::end_(r), o, x); | |
} | |
}; | |
struct remove_copy_if | |
{ | |
template<class R, class O, class P> | |
struct result | |
: detail::decay_array<O> | |
{}; | |
template<class R, class O, class P> | |
typename result<R,O,P>::type | |
operator()(R& r, O o, P p) const | |
{ | |
return std::remove_copy_if(detail::begin_(r), detail::end_(r), o, p); | |
} | |
}; | |
struct unique | |
{ | |
template<class R, class P = void> | |
struct result : range_result_iterator<R> | |
{ | |
}; | |
template<class R> | |
typename result<R>::type execute(R& r, mpl::true_) const | |
{ | |
r.unique(); | |
return detail::end_(r); | |
} | |
template<class R> | |
typename result<R>::type execute(R& r, mpl::false_) const | |
{ | |
return std::unique(detail::begin_(r), detail::end_(r)); | |
} | |
template<class R> | |
typename result<R>::type operator()(R& r) const | |
{ | |
return execute(r, has_unique<R>()); | |
} | |
template<class R, class P> | |
typename result<R>::type execute(R& r, P p, mpl::true_) const | |
{ | |
r.unique(p); | |
return detail::end_(r); | |
} | |
template<class R, class P> | |
typename result<R, P>::type execute(R& r, P p, mpl::false_) const | |
{ | |
return std::unique(detail::begin_(r), detail::end_(r), p); | |
} | |
template<class R, class P> | |
typename result<R, P>::type operator()(R& r, P p) const | |
{ | |
return execute(r, p, has_unique<R>()); | |
} | |
}; | |
struct unique_copy | |
{ | |
template<class R, class O, class P = void> | |
struct result | |
: detail::decay_array<O> | |
{}; | |
template<class R, class O> | |
typename result<R, O>::type operator()(R& r, O o) const | |
{ | |
return std::unique_copy( | |
detail::begin_(r) | |
, detail::end_(r) | |
, o | |
); | |
} | |
template<class R, class O, class P> | |
typename result<R, O, P>::type operator()(R& r, O o, P p) const | |
{ | |
return std::unique_copy( | |
detail::begin_(r) | |
, detail::end_(r) | |
, o | |
, p | |
); | |
} | |
}; | |
struct reverse | |
{ | |
template<class R> | |
struct result | |
{ | |
typedef void type; | |
}; | |
template<class R> | |
void execute(R& r, mpl::true_) const | |
{ | |
r.reverse(); | |
} | |
template<class R> | |
void execute(R& r, mpl::false_) const | |
{ | |
std::reverse(detail::begin_(r), detail::end_(r)); | |
} | |
template<class R> | |
void operator()(R& r) const | |
{ | |
execute(r, has_reverse<R>()); | |
} | |
}; | |
struct reverse_copy | |
{ | |
template<class R, class O> | |
struct result | |
: detail::decay_array<O> | |
{}; | |
template<class R, class O> | |
typename result<R, O>::type operator()(R& r, O o) const | |
{ | |
return std::reverse_copy( | |
detail::begin_(r) | |
, detail::end_(r) | |
, o | |
); | |
} | |
}; | |
struct rotate | |
{ | |
template<class R, class M> | |
struct result | |
{ | |
typedef void type; | |
}; | |
template<class R, class M> | |
void operator()(R& r, M m) const | |
{ | |
std::rotate( | |
detail::begin_(r) | |
, m | |
, detail::end_(r) | |
); | |
} | |
}; | |
struct rotate_copy | |
{ | |
template<class R, class M, class O> | |
struct result | |
: detail::decay_array<O> | |
{}; | |
template<class R, class M, class O> | |
typename result<R, M, O>::type operator()(R& r, M m, O o) const | |
{ | |
return std::rotate_copy( | |
detail::begin_(r) | |
, m | |
, detail::end_(r) | |
, o | |
); | |
} | |
}; | |
struct random_shuffle | |
{ | |
template<class R, class G = void> | |
struct result | |
{ | |
typedef void type; | |
}; | |
template<class R> | |
void operator()(R& r) const | |
{ | |
return std::random_shuffle(detail::begin_(r), detail::end_(r)); | |
} | |
template<class R, class G> | |
void operator()(R& r, G g) const | |
{ | |
return std::random_shuffle(detail::begin_(r), detail::end_(r), g); | |
} | |
}; | |
struct partition | |
{ | |
template<class R, class P> | |
struct result : range_result_iterator<R> | |
{}; | |
template<class R, class P> | |
typename result<R, P>::type operator()(R& r, P p) const | |
{ | |
return std::partition(detail::begin_(r), detail::end_(r), p); | |
} | |
}; | |
struct stable_partition | |
{ | |
template<class R, class P> | |
struct result : range_result_iterator<R> | |
{}; | |
template<class R, class P> | |
typename result<R, P>::type operator()(R& r, P p) const | |
{ | |
return std::stable_partition(detail::begin_(r), detail::end_(r), p); | |
} | |
}; | |
struct sort | |
{ | |
template<class R, class C = void> | |
struct result | |
{ | |
typedef void type; | |
}; | |
template<class R> | |
void execute(R& r, mpl::true_) const | |
{ | |
r.sort(); | |
} | |
template<class R> | |
void execute(R& r, mpl::false_) const | |
{ | |
std::sort(detail::begin_(r), detail::end_(r)); | |
} | |
template<class R> | |
void operator()(R& r) const | |
{ | |
execute(r, has_sort<R>()); | |
} | |
template<class R, class C> | |
void execute(R& r, C c, mpl::true_) const | |
{ | |
r.sort(c); | |
} | |
template<class R, class C> | |
void execute(R& r, C c, mpl::false_) const | |
{ | |
std::sort(detail::begin_(r), detail::end_(r), c); | |
} | |
template<class R, class C> | |
void operator()(R& r, C c) const | |
{ | |
execute(r, c, has_sort<R>()); | |
} | |
}; | |
struct stable_sort | |
{ | |
template<class R, class C = void> | |
struct result | |
{ | |
typedef void type; | |
}; | |
template<class R> | |
void operator()(R& r) const | |
{ | |
std::stable_sort(detail::begin_(r), detail::end_(r)); | |
} | |
template<class R, class C> | |
void operator()(R& r, C c) const | |
{ | |
std::stable_sort(detail::begin_(r), detail::end_(r), c); | |
} | |
}; | |
struct partial_sort | |
{ | |
template<class R, class M, class C = void> | |
struct result | |
{ | |
typedef void type; | |
}; | |
template<class R, class M> | |
void operator()(R& r, M m) const | |
{ | |
std::partial_sort(detail::begin_(r), m, detail::end_(r)); | |
} | |
template<class R, class M, class C> | |
void operator()(R& r, M m, C c) const | |
{ | |
std::partial_sort(detail::begin_(r), m, detail::end_(r), c); | |
} | |
}; | |
struct partial_sort_copy | |
{ | |
template<class R1, class R2, class C = void> | |
struct result : range_result_iterator<R2> | |
{}; | |
template<class R1, class R2> | |
typename result<R1, R2>::type operator()(R1& r1, R2& r2) const | |
{ | |
return std::partial_sort_copy( | |
detail::begin_(r1), detail::end_(r1) | |
, detail::begin_(r2), detail::end_(r2) | |
); | |
} | |
template<class R1, class R2, class C> | |
typename result<R1, R2>::type operator()(R1& r1, R2& r2, C c) const | |
{ | |
return std::partial_sort_copy( | |
detail::begin_(r1), detail::end_(r1) | |
, detail::begin_(r2), detail::end_(r2) | |
, c | |
); | |
} | |
}; | |
struct nth_element | |
{ | |
template<class R, class N, class C = void> | |
struct result | |
{ | |
typedef void type; | |
}; | |
template<class R, class N> | |
void operator()(R& r, N n) const | |
{ | |
return std::nth_element(detail::begin_(r), n, detail::end_(r)); | |
} | |
template<class R, class N, class C> | |
void operator()(R& r, N n, C c) const | |
{ | |
return std::nth_element(detail::begin_(r), n, detail::end_(r), c); | |
} | |
}; | |
struct merge | |
{ | |
template<class R1, class R2, class O, class C = void> | |
struct result | |
: detail::decay_array<O> | |
{}; | |
template<class R1, class R2, class O> | |
typename result<R1, R2, O>::type operator()(R1& r1, R2& r2, O o) const | |
{ | |
return std::merge( | |
detail::begin_(r1), detail::end_(r1) | |
, detail::begin_(r2), detail::end_(r2) | |
, o | |
); | |
} | |
template<class R1, class R2, class O, class C> | |
typename result<R1, R2, O, C>::type operator()(R1& r1, R2& r2, O o, C c) const | |
{ | |
return std::merge( | |
detail::begin_(r1), detail::end_(r1) | |
, detail::begin_(r2), detail::end_(r2) | |
, o | |
, c | |
); | |
} | |
}; | |
struct inplace_merge | |
{ | |
template<class R, class M, class C = void> | |
struct result | |
{ | |
typedef void type; | |
}; | |
template<class R, class M> | |
void operator()(R& r, M m) const | |
{ | |
return std::inplace_merge(detail::begin_(r), m, detail::end_(r)); | |
} | |
template<class R, class M, class C> | |
void operator()(R& r, M m, C c) const | |
{ | |
return std::inplace_merge(detail::begin_(r), m, detail::end_(r), c); | |
} | |
}; | |
struct next_permutation | |
{ | |
template<class R, class C = void> | |
struct result | |
{ | |
typedef bool type; | |
}; | |
template<class R> | |
bool operator()(R& r) const | |
{ | |
return std::next_permutation(detail::begin_(r), detail::end_(r)); | |
} | |
template<class R, class C> | |
bool operator()(R& r, C c) const | |
{ | |
return std::next_permutation(detail::begin_(r), detail::end_(r), c); | |
} | |
}; | |
struct prev_permutation | |
{ | |
template<class R, class C = void> | |
struct result | |
{ | |
typedef bool type; | |
}; | |
template<class R> | |
bool operator()(R& r) const | |
{ | |
return std::prev_permutation(detail::begin_(r), detail::end_(r)); | |
} | |
template<class R, class C> | |
bool operator()(R& r, C c) const | |
{ | |
return std::prev_permutation(detail::begin_(r), detail::end_(r), c); | |
} | |
}; | |
struct inner_product | |
{ | |
template<class R, class I, class T, class C1 = void, class C2 = void> | |
struct result | |
{ | |
typedef T type; | |
}; | |
template<class R, class I, class T> | |
typename result<R,I,T>::type | |
operator()(R& r, I i, T t) const | |
{ | |
return std::inner_product( | |
detail::begin_(r), detail::end_(r), i, t); | |
} | |
template<class R, class I, class T, class C1, class C2> | |
typename result<R,I,T,C1,C2>::type | |
operator()(R& r, I i, T t, C1 c1, C2 c2) const | |
{ | |
return std::inner_product( | |
detail::begin_(r), detail::end_(r), i, | |
t, c1, c2); | |
} | |
}; | |
struct partial_sum | |
{ | |
template<class R, class I, class C = void> | |
struct result | |
: detail::decay_array<I> | |
{}; | |
template<class R, class I> | |
typename result<R,I>::type | |
operator()(R& r, I i) const | |
{ | |
return std::partial_sum( | |
detail::begin_(r), detail::end_(r), i); | |
} | |
template<class R, class I, class C> | |
typename result<R,I,C>::type | |
operator()(R& r, I i, C c) const | |
{ | |
return std::partial_sum( | |
detail::begin_(r), detail::end_(r), i, c); | |
} | |
}; | |
struct adjacent_difference | |
{ | |
template<class R, class I, class C = void> | |
struct result | |
: detail::decay_array<I> | |
{}; | |
template<class R, class I> | |
typename result<R,I>::type | |
operator()(R& r, I i) const | |
{ | |
return std::adjacent_difference( | |
detail::begin_(r), detail::end_(r), i); | |
} | |
template<class R, class I, class C> | |
typename result<R,I,C>::type | |
operator()(R& r, I i, C c) const | |
{ | |
return std::adjacent_difference( | |
detail::begin_(r), detail::end_(r), i, c); | |
} | |
}; | |
struct push_heap | |
{ | |
template<class R, class C = void> | |
struct result | |
{ | |
typedef void type; | |
}; | |
template<class R> | |
void operator()(R& r) const | |
{ | |
std::push_heap(detail::begin_(r), detail::end_(r)); | |
} | |
template<class R, class C> | |
void operator()(R& r, C c) const | |
{ | |
std::push_heap(detail::begin_(r), detail::end_(r), c); | |
} | |
}; | |
struct pop_heap | |
{ | |
template<class R, class C = void> | |
struct result | |
{ | |
typedef void type; | |
}; | |
template<class R> | |
void operator()(R& r) const | |
{ | |
std::pop_heap(detail::begin_(r), detail::end_(r)); | |
} | |
template<class R, class C> | |
void operator()(R& r, C c) const | |
{ | |
std::pop_heap(detail::begin_(r), detail::end_(r), c); | |
} | |
}; | |
struct make_heap | |
{ | |
template<class R, class C = void> | |
struct result | |
{ | |
typedef void type; | |
}; | |
template<class R> | |
void operator()(R& r) const | |
{ | |
std::make_heap(detail::begin_(r), detail::end_(r)); | |
} | |
template<class R, class C> | |
void operator()(R& r, C c) const | |
{ | |
std::make_heap(detail::begin_(r), detail::end_(r), c); | |
} | |
}; | |
struct sort_heap | |
{ | |
template<class R, class C = void> | |
struct result | |
{ | |
typedef void type; | |
}; | |
template<class R> | |
void operator()(R& r) const | |
{ | |
std::sort_heap(detail::begin_(r), detail::end_(r)); | |
} | |
template<class R, class C> | |
void operator()(R& r, C c) const | |
{ | |
std::sort_heap(detail::begin_(r), detail::end_(r), c); | |
} | |
}; | |
struct set_union | |
{ | |
template<class R1, class R2, class O, class C = void> | |
struct result | |
: detail::decay_array<O> | |
{}; | |
template<class R1, class R2, class O> | |
typename result<R1, R2, O>::type operator()(R1& r1, R2& r2, O o) const | |
{ | |
return std::set_union( | |
detail::begin_(r1), detail::end_(r1) | |
, detail::begin_(r2), detail::end_(r2) | |
, o | |
); | |
} | |
template<class R1, class R2, class O, class C> | |
typename result<R1, R2, O, C>::type operator()(R1& r1, R2& r2, O o, C c) const | |
{ | |
return std::set_union( | |
detail::begin_(r1), detail::end_(r1) | |
, detail::begin_(r2), detail::end_(r2) | |
, o | |
, c | |
); | |
} | |
}; | |
struct set_intersection | |
{ | |
template<class R1, class R2, class O, class C = void> | |
struct result | |
: detail::decay_array<O> | |
{}; | |
template<class R1, class R2, class O> | |
typename result<R1, R2, O>::type operator()(R1& r1, R2& r2, O o) const | |
{ | |
return std::set_intersection( | |
detail::begin_(r1), detail::end_(r1) | |
, detail::begin_(r2), detail::end_(r2) | |
, o | |
); | |
} | |
template<class R1, class R2, class O, class C> | |
typename result<R1, R2, O, C>::type operator()(R1& r1, R2& r2, O o, C c) const | |
{ | |
return std::set_intersection( | |
detail::begin_(r1), detail::end_(r1) | |
, detail::begin_(r2), detail::end_(r2) | |
, o | |
, c | |
); | |
} | |
}; | |
struct set_difference | |
{ | |
template<class R1, class R2, class O, class C = void> | |
struct result | |
: detail::decay_array<O> | |
{}; | |
template<class R1, class R2, class O> | |
typename result<R1, R2, O>::type operator()(R1& r1, R2& r2, O o) const | |
{ | |
return std::set_difference( | |
detail::begin_(r1), detail::end_(r1) | |
, detail::begin_(r2), detail::end_(r2) | |
, o | |
); | |
} | |
template<class R1, class R2, class O, class C> | |
typename result<R1, R2, O, C>::type operator()(R1& r1, R2& r2, O o, C c) const | |
{ | |
return std::set_difference( | |
detail::begin_(r1), detail::end_(r1) | |
, detail::begin_(r2), detail::end_(r2) | |
, o | |
, c | |
); | |
} | |
}; | |
struct set_symmetric_difference | |
{ | |
template<class R1, class R2, class O, class C = void> | |
struct result | |
: detail::decay_array<O> | |
{}; | |
template<class R1, class R2, class O> | |
typename result<R1, R2, O>::type operator()(R1& r1, R2& r2, O o) const | |
{ | |
return std::set_symmetric_difference( | |
detail::begin_(r1), detail::end_(r1) | |
, detail::begin_(r2), detail::end_(r2) | |
, o | |
); | |
} | |
template<class R1, class R2, class O, class C> | |
typename result<R1, R2, O, C>::type operator()(R1& r1, R2& r2, O o, C c) const | |
{ | |
return std::set_symmetric_difference( | |
detail::begin_(r1), detail::end_(r1) | |
, detail::begin_(r2), detail::end_(r2) | |
, o | |
, c | |
); | |
} | |
}; | |
}}} // boost::phoenix::impl | |
namespace boost { namespace phoenix | |
{ | |
function<impl::swap> const swap = impl::swap(); | |
function<impl::copy> const copy = impl::copy(); | |
function<impl::copy_backward> const copy_backward = impl::copy_backward(); | |
function<impl::transform> const transform = impl::transform(); | |
function<impl::replace> const replace = impl::replace(); | |
function<impl::replace_if> const replace_if = impl::replace_if(); | |
function<impl::replace_copy> const replace_copy = impl::replace_copy(); | |
function<impl::replace_copy_if> const replace_copy_if = impl::replace_copy_if(); | |
function<impl::fill> const fill = impl::fill(); | |
function<impl::fill_n> const fill_n = impl::fill_n(); | |
function<impl::generate> const generate = impl::generate(); | |
function<impl::generate_n> const generate_n = impl::generate_n(); | |
function<impl::remove> const remove = impl::remove(); | |
function<impl::remove_if> const remove_if = impl::remove_if(); | |
function<impl::remove_copy> const remove_copy = impl::remove_copy(); | |
function<impl::remove_copy_if> const remove_copy_if = impl::remove_copy_if(); | |
function<impl::unique> const unique = impl::unique(); | |
function<impl::unique_copy> const unique_copy = impl::unique_copy(); | |
function<impl::reverse> const reverse = impl::reverse(); | |
function<impl::reverse_copy> const reverse_copy = impl::reverse_copy(); | |
function<impl::rotate> const rotate = impl::rotate(); | |
function<impl::rotate_copy> const rotate_copy = impl::rotate_copy(); | |
function<impl::random_shuffle> const random_shuffle = impl::random_shuffle(); | |
function<impl::partition> const partition = impl::partition(); | |
function<impl::stable_partition> const stable_partition = impl::stable_partition(); | |
function<impl::sort> const sort = impl::sort(); | |
function<impl::stable_sort> const stable_sort = impl::stable_sort(); | |
function<impl::partial_sort> const partial_sort = impl::partial_sort(); | |
function<impl::partial_sort_copy> const partial_sort_copy = impl::partial_sort_copy(); | |
function<impl::nth_element> const nth_element = impl::nth_element(); | |
function<impl::merge> const merge = impl::merge(); | |
function<impl::inplace_merge> const inplace_merge = impl::inplace_merge(); | |
function<impl::next_permutation> const next_permutation = impl::next_permutation(); | |
function<impl::prev_permutation> const prev_permutation = impl::prev_permutation(); | |
function<impl::inner_product> const inner_product = impl::inner_product(); | |
function<impl::partial_sum> const partial_sum = impl::partial_sum(); | |
function<impl::adjacent_difference> const adjacent_difference = impl::adjacent_difference(); | |
function<impl::push_heap> const push_heap = impl::push_heap(); | |
function<impl::pop_heap> const pop_heap = impl::pop_heap(); | |
function<impl::make_heap> const make_heap = impl::make_heap(); | |
function<impl::sort_heap> const sort_heap = impl::sort_heap(); | |
function<impl::set_union> const set_union = impl::set_union(); | |
function<impl::set_intersection> const set_intersection = impl::set_intersection(); | |
function<impl::set_difference> const set_difference = impl::set_difference(); | |
function<impl::set_symmetric_difference> const set_symmetric_difference = impl::set_symmetric_difference(); | |
}} | |
#endif |