| // 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 |