Chris@16: // Copyright 2005 Daniel Wallin. 
Chris@16: // Copyright 2005 Joel de Guzman.
Chris@16: // Copyright 2005 Dan Marsden. 
Chris@16: //
Chris@16: // Use, modification and distribution is subject to the Boost Software 
Chris@16: // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
Chris@16: // http://www.boost.org/LICENSE_1_0.txt)
Chris@16: //
Chris@16: // Modeled after range_ex, Copyright 2004 Eric Niebler
Chris@16: 
Chris@16: #ifndef BOOST_PHOENIX_ALGORITHM_TRANSFORMATION_HPP
Chris@16: #define BOOST_PHOENIX_ALGORITHM_TRANSFORMATION_HPP
Chris@16: 
Chris@16: #include <algorithm>
Chris@16: #include <numeric>
Chris@16: 
Chris@16: #include <boost/phoenix/core/limits.hpp>
Chris@16: #include <boost/phoenix/stl/algorithm/detail/has_sort.hpp>
Chris@16: #include <boost/phoenix/stl/algorithm/detail/has_remove.hpp>
Chris@16: #include <boost/phoenix/stl/algorithm/detail/has_remove_if.hpp>
Chris@16: #include <boost/phoenix/stl/algorithm/detail/has_unique.hpp>
Chris@16: #include <boost/phoenix/stl/algorithm/detail/has_reverse.hpp>
Chris@16: #include <boost/phoenix/stl/algorithm/detail/has_sort.hpp>
Chris@16: 
Chris@16: #include <boost/phoenix/stl/algorithm/detail/begin.hpp>
Chris@16: #include <boost/phoenix/stl/algorithm/detail/end.hpp>
Chris@16: #include <boost/phoenix/stl/algorithm/detail/decay_array.hpp>
Chris@16: 
Chris@16: #include <boost/phoenix/function/adapt_callable.hpp>
Chris@16: 
Chris@16: #include <boost/range/result_iterator.hpp>
Chris@16: #include <boost/range/difference_type.hpp>
Chris@16: 
Chris@16: #include <boost/mpl/if.hpp>
Chris@16: 
Chris@16: #include <boost/type_traits/is_void.hpp>
Chris@16: 
Chris@16: namespace boost { namespace phoenix { namespace impl
Chris@16: {
Chris@16:     struct swap
Chris@16:     {
Chris@16:         typedef void result_type;
Chris@16: 
Chris@16:         template <class A, class B>
Chris@16:         void operator()(A& a, B& b) const
Chris@16:         {
Chris@16:             using std::swap;
Chris@16:             swap(a, b);
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     struct copy
Chris@16:     {
Chris@16:         template <typename Sig>
Chris@16:         struct result;
Chris@16: 
Chris@16:         template<typename This, class R, class I>
Chris@16:         struct result<This(R&, I)>
Chris@16:             : detail::decay_array<I>
Chris@16:         {};
Chris@16: 
Chris@16:         template<class R, class I>
Chris@16:         typename detail::decay_array<I>::type
Chris@16:         operator()(R& r, I i) const
Chris@16:         {
Chris@16:             return std::copy(detail::begin_(r), detail::end_(r), i);
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     struct copy_backward
Chris@16:     {
Chris@16:         template <typename Sig>
Chris@16:         struct result;
Chris@16: 
Chris@16:         template<typename This, class R, class I>
Chris@16:         struct result<This(R&, I)>
Chris@16:             : result<This(R&, I const &)>
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename This, class R, class I>
Chris@16:         struct result<This(R&, I &)>
Chris@16:         {
Chris@16:             typedef I type;
Chris@16:         };
Chris@16: 
Chris@16:         template<class R, class I>
Chris@16:         I operator()(R& r, I & i) const
Chris@16:         {
Chris@16:             return std::copy_backward(detail::begin_(r), detail::end_(r), i);
Chris@16:         }
Chris@16: 
Chris@16:         template<class R, class I>
Chris@16:         I const operator()(R& r, I const & i) const
Chris@16:         {
Chris@16:             return std::copy_backward(detail::begin_(r), detail::end_(r), i);
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     struct transform
Chris@16:     {
Chris@16:         template <typename Sig>
Chris@16:         struct result;
Chris@16:         
Chris@16:         template<typename This, class R, class OutorI1, class ForOut>
Chris@16:         struct result<This(R&, OutorI1, ForOut)>
Chris@16:             : detail::decay_array<OutorI1>
Chris@16:         {
Chris@16:         };
Chris@16: 
Chris@16:         template<typename This, class R, class OutorI1, class ForOut, class BinF>
Chris@16:         struct result<This(R&, OutorI1, ForOut, BinF)>
Chris@16:             : detail::decay_array<ForOut>
Chris@16:         {
Chris@16:         };
Chris@16: 
Chris@16:         template<class R, class O, class F>
Chris@16:         typename result<transform(R&,O,F)>::type
Chris@16:         operator()(R& r, O o, F f) const
Chris@16:         {
Chris@16:             return std::transform(detail::begin_(r), detail::end_(r), o, f);
Chris@16:         }
Chris@16: 
Chris@16:         template<class R, class I, class O, class F>
Chris@16:         typename result<transform(R&,I,O,F)>::type
Chris@16:         operator()(R& r, I i, O o, F f) const
Chris@16:         {
Chris@16:             return std::transform(detail::begin_(r), detail::end_(r), i, o, f);
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     struct replace
Chris@16:     {
Chris@16:         typedef void result_type;
Chris@16: 
Chris@16:         template<class R, class T>
Chris@16:         void operator()(R& r, T const& what, T const& with) const
Chris@16:         {
Chris@16:             std::replace(detail::begin_(r), detail::end_(r), what, with);
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     struct replace_if
Chris@16:     {
Chris@16:         typedef void result_type;
Chris@16: 
Chris@16:         template<class R, class P, class T>
Chris@16:         void operator()(R& r, P p, T const& with) const
Chris@16:         {
Chris@16:             std::replace_if(detail::begin_(r), detail::end_(r), p, with);
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     struct replace_copy
Chris@16:     {
Chris@16:         template <typename Sig>
Chris@16:         struct result;
Chris@16: 
Chris@16:         template<typename This, class R, class O, class T, class T2>
Chris@16:         struct result<This(R&, O, T const&, T2 const&)>
Chris@16:             : detail::decay_array<O>
Chris@16:         {};
Chris@16: 
Chris@16:         template<class R, class O, class T>
Chris@16:         typename detail::decay_array<O>::type 
Chris@16:         operator()(R& r, O o, T const& what, T const& with) const
Chris@16:         {
Chris@16:             return std::replace_copy(detail::begin_(r), detail::end_(r), o, what, with);
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     struct replace_copy_if
Chris@16:     {
Chris@16:         template <typename Sig>
Chris@16:         struct result;
Chris@16: 
Chris@16:         template<typename This, class R, class O, class P, class T>
Chris@16:         struct result<This(R&, O, P, T const&)>
Chris@16:             : detail::decay_array<O>
Chris@16:         {};
Chris@16: 
Chris@16:         template<class R, class O, class P, class T>
Chris@16:         typename detail::decay_array<O>::type
Chris@16:         operator()(R& r, O o, P p, T const& with) const
Chris@16:         {
Chris@16:             return std::replace_copy_if(detail::begin_(r), detail::end_(r), o, p, with);
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     struct fill
Chris@16:     {
Chris@16:         typedef void result_type;
Chris@16: 
Chris@16:         template<class R, class T>
Chris@16:         void operator()(R& r, T const& x) const
Chris@16:         {
Chris@16:             std::fill(detail::begin_(r), detail::end_(r), x);
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     struct fill_n
Chris@16:     {
Chris@16:         typedef void result_type;
Chris@16: 
Chris@16:         template<class R, class N, class T>
Chris@16:         void operator()(R& r, N n, T const& x) const
Chris@16:         {
Chris@16:             std::fill_n(detail::begin_(r), n, x);
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     struct generate
Chris@16:     {
Chris@16:         typedef void result_type;
Chris@16: 
Chris@16:         template<class R, class G>
Chris@16:         void operator()(R& r, G const & g) const
Chris@16:         {
Chris@16:             std::generate(detail::begin_(r), detail::end_(r), g);
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     struct generate_n
Chris@16:     {
Chris@16:         typedef void result_type;
Chris@16: 
Chris@16:         template<class R, class N, class G>
Chris@16:         void operator()(R& r, N n, G g) const
Chris@16:         {
Chris@16:             std::generate_n(detail::begin_(r), n, g);
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     struct remove
Chris@16:     {
Chris@16:         template <typename Sig>
Chris@16:         struct result;
Chris@16: 
Chris@16:         template<typename This, class R, class T>
Chris@16:         struct result<This(R&, T const&)>
Chris@16:             : range_result_iterator<R>
Chris@16:         {
Chris@16:         };
Chris@16: 
Chris@16:         template<class R, class T>
Chris@16:         typename range_result_iterator<R>::type
Chris@16:         execute(R& r, T const& x, mpl::true_) const
Chris@16:         {
Chris@16:             r.remove(x);
Chris@16:             return detail::end_(r);
Chris@16:         }
Chris@16: 
Chris@16:         template<class R, class T>
Chris@16:         typename range_result_iterator<R>::type
Chris@16:         execute(R& r, T const& x, mpl::false_) const
Chris@16:         {
Chris@16:             return std::remove(detail::begin_(r), detail::end_(r), x);
Chris@16:         }
Chris@16: 
Chris@16:         template<class R, class T>
Chris@16:         typename range_result_iterator<R>::type
Chris@16:         operator()(R& r, T const& x) const
Chris@16:         {
Chris@16:             return execute(r, x, has_remove<R>());
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     struct remove_if
Chris@16:     {
Chris@16:         template <typename Sig>
Chris@16:         struct result;
Chris@16: 
Chris@16:         template <typename This, class R, class P>
Chris@16:         struct result<This(R&,P)>
Chris@16:             : range_result_iterator<R>
Chris@16:         {
Chris@16:         };
Chris@16: 
Chris@16:         template<class R, class P>
Chris@16:         typename range_result_iterator<R>::type
Chris@16:         execute(R& r, P p, mpl::true_) const
Chris@16:         {
Chris@16:             r.remove_if(p);
Chris@16:             return detail::end_(r);
Chris@16:         }
Chris@16: 
Chris@16:         template<class R, class P>
Chris@16:         typename range_result_iterator<R>::type
Chris@16:         execute(R& r, P p, mpl::false_) const
Chris@16:         {
Chris@16:             return std::remove_if(detail::begin_(r), detail::end_(r), p);
Chris@16:         }
Chris@16: 
Chris@16:         template<class R, class P>
Chris@16:         typename range_result_iterator<R>::type
Chris@16:         operator()(R& r, P p) const
Chris@16:         {
Chris@16:             return execute(r, p, has_remove_if<R>());
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     struct remove_copy
Chris@16:     {
Chris@16:         template <typename Sig>
Chris@16:         struct result;
Chris@16: 
Chris@16:         template<typename This, class R, class O, class T>
Chris@16:         struct result<This(R&, O, T)>
Chris@16:             : detail::decay_array<O>
Chris@16:         {};
Chris@16: 
Chris@16:         template<class R, class O, class T>
Chris@16:         typename detail::decay_array<O>::type
Chris@16:         operator()(R& r, O o, T const& x) const
Chris@16:         {
Chris@16:             return std::remove_copy(detail::begin_(r), detail::end_(r), o, x);
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     struct remove_copy_if
Chris@16:     {
Chris@16:         template <typename Sig>
Chris@16:         struct result;
Chris@16: 
Chris@16:         template<typename This, class R, class O, class P>
Chris@16:         struct result<This(R&, O, P)>
Chris@16:             : detail::decay_array<O>
Chris@16:         {};
Chris@16: 
Chris@16:         template<class R, class O, class P>
Chris@16:         typename detail::decay_array<O>::type
Chris@16:         operator()(R& r, O o, P p) const
Chris@16:         {
Chris@16:             return std::remove_copy_if(detail::begin_(r), detail::end_(r), o, p);
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     struct unique
Chris@16:     {
Chris@16:         template <typename Sig>
Chris@16:         struct result;
Chris@16: 
Chris@16:         template<typename This, class R>
Chris@16:         struct result<This(R&)>
Chris@16:             : range_result_iterator<R>
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename This, class R, class P>
Chris@16:         struct result<This(R&, P)>
Chris@16:             : range_result_iterator<R>
Chris@16:         {};
Chris@16: 
Chris@16:         template<class R>
Chris@16:         typename range_result_iterator<R>::type
Chris@16:         execute(R& r, mpl::true_) const
Chris@16:         {
Chris@16:             r.unique();
Chris@16:             return detail::end_(r);
Chris@16:         }
Chris@16: 
Chris@16:         template<class R>
Chris@16:         typename range_result_iterator<R>::type
Chris@16:         execute(R& r, mpl::false_) const
Chris@16:         {
Chris@16:             return std::unique(detail::begin_(r), detail::end_(r));
Chris@16:         }
Chris@16: 
Chris@16:         template<class R>
Chris@16:         typename range_result_iterator<R>::type
Chris@16:         operator()(R& r) const
Chris@16:         {
Chris@16:             return execute(r, has_unique<R>());
Chris@16:         }
Chris@16: 
Chris@16: 
Chris@16:         template<class R, class P>
Chris@16:         typename range_result_iterator<R>::type
Chris@16:         execute(R& r, P p, mpl::true_) const
Chris@16:         {
Chris@16:             r.unique(p);
Chris@16:             return detail::end_(r);
Chris@16:         }
Chris@16: 
Chris@16:         template<class R, class P>
Chris@16:         typename range_result_iterator<R>::type
Chris@16:         execute(R& r, P p, mpl::false_) const
Chris@16:         {
Chris@16:             return std::unique(detail::begin_(r), detail::end_(r), p);
Chris@16:         }
Chris@16: 
Chris@16:         template<class R, class P>
Chris@16:         typename range_result_iterator<R>::type
Chris@16:         operator()(R& r, P p) const
Chris@16:         {
Chris@16:             return execute(r, p, has_unique<R>());
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     struct unique_copy
Chris@16:     {
Chris@16:         template <typename Sig>
Chris@16:         struct result;
Chris@16: 
Chris@16:         template<typename This, class R, class O>
Chris@16:         struct result<This(R&, O)>
Chris@16:             : detail::decay_array<O>
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename This, class R, class O, class P>
Chris@16:         struct result<This(R&, O, P)>
Chris@16:             : detail::decay_array<O>
Chris@16:         {};
Chris@16: 
Chris@16:         template<class R, class O>
Chris@16:         typename detail::decay_array<O>::type operator()(R& r, O o) const
Chris@16:         {
Chris@16:             return std::unique_copy(
Chris@16:                 detail::begin_(r)
Chris@16:                 , detail::end_(r)
Chris@16:                 , o
Chris@16:                 );
Chris@16:         }
Chris@16: 
Chris@16:         template<class R, class O, class P>
Chris@16:         typename detail::decay_array<O>::type operator()(R& r, O o, P p) const
Chris@16:         {
Chris@16:             return std::unique_copy(
Chris@16:                 detail::begin_(r)
Chris@16:                 , detail::end_(r)
Chris@16:                 , o
Chris@16:                 , p
Chris@16:                 );
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     struct reverse
Chris@16:     {
Chris@16:         typedef void result_type;
Chris@16: 
Chris@16:         template<class R>
Chris@16:         void execute(R& r, mpl::true_) const
Chris@16:         {
Chris@16:             r.reverse();
Chris@16:         }
Chris@16: 
Chris@16:         template<class R>
Chris@16:         void execute(R& r, mpl::false_) const
Chris@16:         {
Chris@16:             std::reverse(detail::begin_(r), detail::end_(r));
Chris@16:         }
Chris@16: 
Chris@16:         template<class R>
Chris@16:         void operator()(R& r) const
Chris@16:         {
Chris@16:             execute(r, has_reverse<R>());
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     struct reverse_copy
Chris@16:     {
Chris@16:         template <typename Sig>
Chris@16:         struct result;
Chris@16: 
Chris@16:         template<typename This, class R, class O>
Chris@16:         struct result<This(R&, O)>
Chris@16:             : detail::decay_array<O>
Chris@16:         {};
Chris@16: 
Chris@16:         template<class R, class O>
Chris@16:         typename detail::decay_array<O>::type operator()(R& r, O o) const
Chris@16:         {
Chris@16:             return std::reverse_copy(
Chris@16:                 detail::begin_(r)
Chris@16:                 , detail::end_(r)
Chris@16:                 , o
Chris@16:                 );
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     struct rotate
Chris@16:     {
Chris@16:         typedef void result_type;
Chris@16: 
Chris@16:         template<class R, class M>
Chris@16:         void operator()(R& r, M m) const
Chris@16:         {
Chris@16:             std::rotate(
Chris@16:                 detail::begin_(r)
Chris@16:                 , m
Chris@16:                 , detail::end_(r)
Chris@16:                 );
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     struct rotate_copy
Chris@16:     {
Chris@16:         template <typename Sig>
Chris@16:         struct result;
Chris@16: 
Chris@16:         template<typename This, class R, class M, class O>
Chris@16:         struct result<This(R&, M, O)>
Chris@16:             : detail::decay_array<O>
Chris@16:         {};
Chris@16: 
Chris@16:         template<class R, class M, class O>
Chris@16:         typename detail::decay_array<O>::type operator()(R& r, M m, O o) const
Chris@16:         {
Chris@16:             return std::rotate_copy(
Chris@16:                 detail::begin_(r)
Chris@16:                 , m
Chris@16:                 , detail::end_(r)
Chris@16:                 , o
Chris@16:                 );
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     struct random_shuffle
Chris@16:     {
Chris@16:         typedef void result_type;
Chris@16: 
Chris@16:         template<class R>
Chris@16:         void operator()(R& r) const
Chris@16:         {
Chris@16:             return std::random_shuffle(detail::begin_(r), detail::end_(r));
Chris@16:         }
Chris@16: 
Chris@16:         template<class R, class G>
Chris@16:         void operator()(R& r, G g) const
Chris@16:         {
Chris@16:             return std::random_shuffle(detail::begin_(r), detail::end_(r), g);
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     struct partition
Chris@16:     {
Chris@16:         template <typename Sig>
Chris@16:         struct result;
Chris@16: 
Chris@16:         template <typename This, class R, class P>
Chris@16:         struct result<This(R&, P)>
Chris@16:             : range_result_iterator<R>
Chris@16:         {};
Chris@16: 
Chris@16:         template<class R, class P>
Chris@16:         typename range_result_iterator<R>::type
Chris@16:         operator()(R& r, P p) const
Chris@16:         {
Chris@16:             return std::partition(detail::begin_(r), detail::end_(r), p);
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     struct stable_partition
Chris@16:     {
Chris@16:         template <typename Sig>
Chris@16:         struct result;
Chris@16: 
Chris@16:         template <typename This, class R, class P>
Chris@16:         struct result<This(R&, P)>
Chris@16:             : range_result_iterator<R>
Chris@16:         {};
Chris@16: 
Chris@16:         template<class R, class P>
Chris@16:         typename range_result_iterator<R>::type
Chris@16:         operator()(R& r, P p) const
Chris@16:         {
Chris@16:             return std::stable_partition(detail::begin_(r), detail::end_(r), p);
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     struct sort
Chris@16:     {
Chris@16:         typedef void result_type;
Chris@16: 
Chris@16:         template<class R>
Chris@16:         void execute(R& r, mpl::true_) const
Chris@16:         {
Chris@16:             r.sort();
Chris@16:         }
Chris@16: 
Chris@16:         template<class R>
Chris@16:         void execute(R& r, mpl::false_) const
Chris@16:         {
Chris@16:             std::sort(detail::begin_(r), detail::end_(r));
Chris@16:         }
Chris@16: 
Chris@16:         template<class R>
Chris@16:         void operator()(R& r) const
Chris@16:         {
Chris@16:             execute(r, has_sort<R>());
Chris@16:         }
Chris@16: 
Chris@16:         template<class R, class C>
Chris@16:         void execute(R& r, C c, mpl::true_) const
Chris@16:         {
Chris@16:             r.sort(c);
Chris@16:         }
Chris@16: 
Chris@16:         template<class R, class C>
Chris@16:         void execute(R& r, C c, mpl::false_) const
Chris@16:         {
Chris@16:             std::sort(detail::begin_(r), detail::end_(r), c);
Chris@16:         }
Chris@16: 
Chris@16:         template<class R, class C>
Chris@16:         void operator()(R& r, C c) const
Chris@16:         {
Chris@16:             execute(r, c, has_sort<R>());
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     struct stable_sort
Chris@16:     {
Chris@16:         typedef void result_type;
Chris@16: 
Chris@16:         template<class R>
Chris@16:         void operator()(R& r) const
Chris@16:         {
Chris@16:             std::stable_sort(detail::begin_(r), detail::end_(r));
Chris@16:         }
Chris@16: 
Chris@16:         template<class R, class C>
Chris@16:         void operator()(R& r, C c) const
Chris@16:         {
Chris@16:             std::stable_sort(detail::begin_(r), detail::end_(r), c);
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     struct partial_sort
Chris@16:     {
Chris@16:         typedef void result_type;
Chris@16: 
Chris@16:         template<class R, class M>
Chris@16:         void operator()(R& r, M m) const
Chris@16:         {
Chris@16:             std::partial_sort(detail::begin_(r), m, detail::end_(r));
Chris@16:         }
Chris@16: 
Chris@16:         template<class R, class M, class C>
Chris@16:         void operator()(R& r, M m, C c) const
Chris@16:         {
Chris@16:             std::partial_sort(detail::begin_(r), m, detail::end_(r), c);
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     struct partial_sort_copy
Chris@16:     {
Chris@16:         template <typename Sig>
Chris@16:         struct result;
Chris@16:         
Chris@16:         template <typename This, class R1, class R2>
Chris@16:         struct result<This(R1&, R2&)>
Chris@16:             : range_result_iterator<R2>
Chris@16:         {};
Chris@16: 
Chris@16:         template <typename This, class R1, class R2, class C>
Chris@16:         struct result<This(R1&, R2&, C)>
Chris@16:             : range_result_iterator<R2>
Chris@16:         {};
Chris@16: 
Chris@16:         template <class R1, class R2>
Chris@16:         typename range_result_iterator<R2>::type
Chris@16:         operator()(R1& r1, R2& r2) const
Chris@16:         {
Chris@16:             return std::partial_sort_copy(
Chris@16:                 detail::begin_(r1), detail::end_(r1)
Chris@16:                 , detail::begin_(r2), detail::end_(r2)
Chris@16:                 );
Chris@16:         }
Chris@16: 
Chris@16:         template <class R1, class R2, class C>
Chris@16:         typename range_result_iterator<R2>::type
Chris@16:         operator()(R1& r1, R2& r2, C c) const
Chris@16:         {
Chris@16:             return std::partial_sort_copy(
Chris@16:                 detail::begin_(r1), detail::end_(r1)
Chris@16:                 , detail::begin_(r2), detail::end_(r2)
Chris@16:                 , c
Chris@16:                 );
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     struct nth_element
Chris@16:     {
Chris@16:         typedef void result_type;
Chris@16: 
Chris@16:         template<class R, class N>
Chris@16:         void operator()(R& r, N n) const
Chris@16:         {
Chris@16:             return std::nth_element(detail::begin_(r), n, detail::end_(r));
Chris@16:         }
Chris@16: 
Chris@16:         template<class R, class N, class C>
Chris@16:         void operator()(R& r, N n, C c) const
Chris@16:         {
Chris@16:             return std::nth_element(detail::begin_(r), n, detail::end_(r), c);
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     struct merge 
Chris@16:     {
Chris@16:         template <typename Sig>
Chris@16:         struct result;
Chris@16: 
Chris@16:         template<typename This, class R1, class R2, class O>
Chris@16:         struct result<This(R1&, R2&, O)>
Chris@16:             : detail::decay_array<O>
Chris@16:         {};
Chris@16: 
Chris@16:         template<typename This, class R1, class R2, class O, class C>
Chris@16:         struct result<This(R1&, R2&, O, C)>
Chris@16:             : detail::decay_array<O>
Chris@16:         {};
Chris@16: 
Chris@16:         template<class R1, class R2, class O>
Chris@16:         typename detail::decay_array<O>::type operator()(R1& r1, R2& r2, O o) const
Chris@16:         {
Chris@16:             return std::merge(
Chris@16:                 detail::begin_(r1), detail::end_(r1)
Chris@16:                 , detail::begin_(r2), detail::end_(r2)
Chris@16:                 , o
Chris@16:                 );
Chris@16:         }
Chris@16: 
Chris@16:         template<class R1, class R2, class O, class C>
Chris@16:         typename detail::decay_array<O>::type operator()(R1& r1, R2& r2, O o, C c) const
Chris@16:         {
Chris@16:             return std::merge(
Chris@16:                 detail::begin_(r1), detail::end_(r1)
Chris@16:                 , detail::begin_(r2), detail::end_(r2)
Chris@16:                 , o
Chris@16:                 , c
Chris@16:                 );
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     struct inplace_merge 
Chris@16:     {
Chris@16:         typedef void result_type;
Chris@16: 
Chris@16:         template<class R, class M>
Chris@16:         void operator()(R& r, M m) const
Chris@16:         {
Chris@16:             return std::inplace_merge(detail::begin_(r), m, detail::end_(r));
Chris@16:         }
Chris@16: 
Chris@16:         template<class R, class M, class C>
Chris@16:         void operator()(R& r, M m, C c) const
Chris@16:         {
Chris@16:             return std::inplace_merge(detail::begin_(r), m, detail::end_(r), c);
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     struct next_permutation
Chris@16:     {
Chris@16:         typedef bool result_type;
Chris@16: 
Chris@16:         template<class R>
Chris@16:         bool operator()(R& r) const
Chris@16:         {
Chris@16:             return std::next_permutation(detail::begin_(r), detail::end_(r));
Chris@16:         }
Chris@16:     
Chris@16:         template<class R, class C>
Chris@16:         bool operator()(R& r, C c) const
Chris@16:         {
Chris@16:             return std::next_permutation(detail::begin_(r), detail::end_(r), c);
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     struct prev_permutation
Chris@16:     {
Chris@16:         typedef bool result_type;
Chris@16: 
Chris@16:         template<class R>
Chris@16:         bool operator()(R& r) const
Chris@16:         {
Chris@16:             return std::prev_permutation(detail::begin_(r), detail::end_(r));
Chris@16:         }
Chris@16:     
Chris@16:         template<class R, class C>
Chris@16:         bool operator()(R& r, C c) const
Chris@16:         {
Chris@16:             return std::prev_permutation(detail::begin_(r), detail::end_(r), c);
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16: 
Chris@16:     struct inner_product
Chris@16:     {
Chris@16:         template <typename Sig>
Chris@16:         struct result;
Chris@16: 
Chris@16:         template <typename This, typename R, typename I, typename T>
Chris@16:         struct result<This(R&, I, T)>
Chris@16:             : result<This(R&, I const &, T)>
Chris@16:         {};
Chris@16: 
Chris@16:         template <typename This, typename R, typename I, typename T>
Chris@16:         struct result<This(R&, I, T &)>
Chris@16:         {
Chris@16:             typedef T type;
Chris@16:         };
Chris@16: 
Chris@16:         template <typename This, typename R, typename I, typename T, typename C1, typename C2>
Chris@16:         struct result<This(R&, I, T, C1, C2)>
Chris@16:             : result<This(R&, I, T const &, C1, C2)>
Chris@16:         {};
Chris@16: 
Chris@16:         template <typename This, typename R, typename I, typename T, typename C1, typename C2>
Chris@16:         struct result<This(R&, I, T &, C1, C2)>
Chris@16:         {
Chris@16:             typedef T type;
Chris@16:         };
Chris@16: 
Chris@16:         template <class R, class I, class T>
Chris@16:         T
Chris@16:         operator()(R& r, I i, T t) const
Chris@16:         {
Chris@16:             return std::inner_product(
Chris@16:                 detail::begin_(r), detail::end_(r), i, t);
Chris@16:         }
Chris@16: 
Chris@16:         template <class R, class I, class T, class C1, class C2>
Chris@16:         T
Chris@16:         operator()(R& r, I i, T t, C1 c1, C2 c2) const
Chris@16:         {
Chris@16:             return std::inner_product(
Chris@16:                 detail::begin_(r), detail::end_(r), i, 
Chris@16:                 t, c1, c2);
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     struct partial_sum
Chris@16:     {
Chris@16:         template <typename Sig>
Chris@16:         struct result;
Chris@16: 
Chris@16:         template <typename This, class R, class I>
Chris@16:         struct result<This(R&, I)>
Chris@16:             : detail::decay_array<I>
Chris@16:         {};
Chris@16: 
Chris@16:         template <typename This, class R, class I, class C>
Chris@16:         struct result<This(R&, I, C)>
Chris@16:             : detail::decay_array<I>
Chris@16:         {};
Chris@16: 
Chris@16:         template <class R, class I>
Chris@16:         typename detail::decay_array<I>::type
Chris@16:         operator()(R& r, I i) const
Chris@16:         {
Chris@16:             return std::partial_sum(
Chris@16:                 detail::begin_(r), detail::end_(r), i);
Chris@16:         }
Chris@16: 
Chris@16:         template <class R, class I, class C>
Chris@16:         typename detail::decay_array<I>::type
Chris@16:         operator()(R& r, I i, C c) const
Chris@16:         {
Chris@16:             return std::partial_sum(
Chris@16:                 detail::begin_(r), detail::end_(r), i, c);
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     struct adjacent_difference
Chris@16:     {
Chris@16:         template <typename Sig>
Chris@16:         struct result;
Chris@16:         
Chris@16:         template <typename This, class R, class I>
Chris@16:         struct result<This(R&, I)>
Chris@16:             : detail::decay_array<I>
Chris@16:         {};
Chris@16: 
Chris@16:         template <typename This,class R, class I, class C>
Chris@16:         struct result<This(R&, I, C)>
Chris@16:             : detail::decay_array<I>
Chris@16:         {};
Chris@16: 
Chris@16:         template <class R, class I>
Chris@16:         typename detail::decay_array<I>::type
Chris@16:         operator()(R& r, I i) const
Chris@16:         {
Chris@16:             return std::adjacent_difference(
Chris@16:                 detail::begin_(r), detail::end_(r), i);
Chris@16:         }
Chris@16: 
Chris@16:         template <class R, class I, class C>
Chris@16:         typename detail::decay_array<I>::type
Chris@16:         operator()(R& r, I i, C c) const
Chris@16:         {
Chris@16:             return std::adjacent_difference(
Chris@16:                 detail::begin_(r), detail::end_(r), i, c);
Chris@16:         }    
Chris@16:     };
Chris@16: 
Chris@16:     struct push_heap
Chris@16:     {
Chris@16:         typedef void result_type;
Chris@16: 
Chris@16:         template <class R>
Chris@16:         void operator()(R& r) const
Chris@16:         {
Chris@16:             std::push_heap(detail::begin_(r), detail::end_(r));
Chris@16:         }
Chris@16: 
Chris@16:         template <class R, class C>
Chris@16:         void operator()(R& r, C c) const
Chris@16:         {
Chris@16:             std::push_heap(detail::begin_(r), detail::end_(r), c);
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     struct pop_heap
Chris@16:     {
Chris@16:         typedef void result_type;
Chris@16: 
Chris@16:         template <class R>
Chris@16:         void operator()(R& r) const
Chris@16:         {
Chris@16:             std::pop_heap(detail::begin_(r), detail::end_(r));
Chris@16:         }
Chris@16: 
Chris@16:         template <class R, class C>
Chris@16:         void operator()(R& r, C c) const
Chris@16:         {
Chris@16:             std::pop_heap(detail::begin_(r), detail::end_(r), c);
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     struct make_heap
Chris@16:     {
Chris@16:         typedef void result_type;
Chris@16: 
Chris@16:         template <class R>
Chris@16:         void operator()(R& r) const
Chris@16:         {
Chris@16:             std::make_heap(detail::begin_(r), detail::end_(r));
Chris@16:         }
Chris@16: 
Chris@16:         template <class R, class C>
Chris@16:         void operator()(R& r, C c) const
Chris@16:         {
Chris@16:             std::make_heap(detail::begin_(r), detail::end_(r), c);
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     struct sort_heap
Chris@16:     {
Chris@16:         typedef void result_type;
Chris@16: 
Chris@16:         template <class R>
Chris@16:         void operator()(R& r) const
Chris@16:         {
Chris@16:             std::sort_heap(detail::begin_(r), detail::end_(r));
Chris@16:         }
Chris@16: 
Chris@16:         template <class R, class C>
Chris@16:         void operator()(R& r, C c) const
Chris@16:         {
Chris@16:             std::sort_heap(detail::begin_(r), detail::end_(r), c);
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     struct set_union
Chris@16:     {
Chris@16:         template <typename Sig>
Chris@16:         struct result;
Chris@16: 
Chris@16:         template <typename This, class R1, class R2, class O>
Chris@16:         struct result<This(R1&, R2&, O)>
Chris@16:             : detail::decay_array<O>
Chris@16:         {};
Chris@16: 
Chris@16:         template <typename This, class R1, class R2, class O, typename C>
Chris@16:         struct result<This(R1&, R2&, O, C)>
Chris@16:             : detail::decay_array<O>
Chris@16:         {};
Chris@16: 
Chris@16:         template <class R1, class R2, class O>
Chris@16:         typename detail::decay_array<O>::type
Chris@16:         operator()(R1& r1, R2& r2, O o) const
Chris@16:         {
Chris@16:             return std::set_union(
Chris@16:                 detail::begin_(r1), detail::end_(r1)
Chris@16:                 , detail::begin_(r2), detail::end_(r2)
Chris@16:                 , o
Chris@16:                 );
Chris@16:         }
Chris@16: 
Chris@16:         template <class R1, class R2, class O, class C>
Chris@16:         typename detail::decay_array<O>::type
Chris@16:         operator()(R1& r1, R2& r2, O o, C c) const
Chris@16:         {
Chris@16:             return std::set_union(
Chris@16:                 detail::begin_(r1), detail::end_(r1)
Chris@16:                 , detail::begin_(r2), detail::end_(r2)
Chris@16:                 , o
Chris@16:                 , c
Chris@16:                 );
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     struct set_intersection
Chris@16:     {
Chris@16:         template <typename Sig>
Chris@16:         struct result;
Chris@16: 
Chris@16:         template <typename This, class R1, class R2, class O>
Chris@16:         struct result<This(R1&, R2&, O)>
Chris@16:             : detail::decay_array<O>
Chris@16:         {};
Chris@16: 
Chris@16:         template <typename This, class R1, class R2, class O, typename C>
Chris@16:         struct result<This(R1&, R2&, O, C)>
Chris@16:             : detail::decay_array<O>
Chris@16:         {};
Chris@16: 
Chris@16:         template <class R1, class R2, class O>
Chris@16:         typename detail::decay_array<O>::type
Chris@16:         operator()(R1& r1, R2& r2, O o) const
Chris@16:         {
Chris@16:             return std::set_intersection(
Chris@16:                 detail::begin_(r1), detail::end_(r1)
Chris@16:                 , detail::begin_(r2), detail::end_(r2)
Chris@16:                 , o
Chris@16:                 );
Chris@16:         }
Chris@16: 
Chris@16:         template <class R1, class R2, class O, class C>
Chris@16:         typename detail::decay_array<O>::type
Chris@16:         operator()(R1& r1, R2& r2, O o, C c) const
Chris@16:         {
Chris@16:             return std::set_intersection(
Chris@16:                 detail::begin_(r1), detail::end_(r1)
Chris@16:                 , detail::begin_(r2), detail::end_(r2)
Chris@16:                 , o
Chris@16:                 , c
Chris@16:                 );
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     struct set_difference
Chris@16:     {
Chris@16:         template <typename Sig>
Chris@16:         struct result;
Chris@16: 
Chris@16:         template <typename This, class R1, class R2, class O>
Chris@16:         struct result<This(R1&, R2&, O)>
Chris@16:             : detail::decay_array<O>
Chris@16:         {};
Chris@16: 
Chris@16:         template <typename This, class R1, class R2, class O, class C>
Chris@16:         struct result<This(R1&, R2&, O, C)>
Chris@16:             : detail::decay_array<O>
Chris@16:         {};
Chris@16: 
Chris@16:         template <class R1, class R2, class O>
Chris@16:         typename detail::decay_array<O>::type
Chris@16:         operator()(R1& r1, R2& r2, O o) const
Chris@16:         {
Chris@16:             return std::set_difference(
Chris@16:                 detail::begin_(r1), detail::end_(r1)
Chris@16:                 , detail::begin_(r2), detail::end_(r2)
Chris@16:                 , o
Chris@16:                 );
Chris@16:         }
Chris@16: 
Chris@16:         template <class R1, class R2, class O, class C>
Chris@16:         typename detail::decay_array<O>::type
Chris@16:         operator()(R1& r1, R2& r2, O o, C c) const
Chris@16:         {
Chris@16:             return std::set_difference(
Chris@16:                 detail::begin_(r1), detail::end_(r1)
Chris@16:                 , detail::begin_(r2), detail::end_(r2)
Chris@16:                 , o
Chris@16:                 , c
Chris@16:                 );
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16:     struct set_symmetric_difference
Chris@16:     {
Chris@16:         template <typename Sig>
Chris@16:         struct result;
Chris@16: 
Chris@16:         template <typename This, class R1, class R2, class O>
Chris@16:         struct result<This(R1&, R2, O)>
Chris@16:             : detail::decay_array<O>
Chris@16:         {};
Chris@16: 
Chris@16:         template <typename This, class R1, class R2, class O, class C>
Chris@16:         struct result<This(R1&, R2, O, C)>
Chris@16:             : detail::decay_array<O>
Chris@16:         {};
Chris@16: 
Chris@16:         template <class R1, class R2, class O>
Chris@16:         typename detail::decay_array<O>::type
Chris@16:         operator()(R1& r1, R2& r2, O o) const
Chris@16:         {
Chris@16:             return std::set_symmetric_difference(
Chris@16:                 detail::begin_(r1), detail::end_(r1)
Chris@16:                 , detail::begin_(r2), detail::end_(r2)
Chris@16:                 , o
Chris@16:                 );
Chris@16:         }
Chris@16: 
Chris@16:         template <class R1, class R2, class O, class C>
Chris@16:         typename detail::decay_array<O>::type
Chris@16:         operator()(R1& r1, R2& r2, O o, C c) const
Chris@16:         {
Chris@16:             return std::set_symmetric_difference(
Chris@16:                 detail::begin_(r1), detail::end_(r1)
Chris@16:                 , detail::begin_(r2), detail::end_(r2)
Chris@16:                 , o
Chris@16:                 , c
Chris@16:                 );
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16: }}} // boost::phoenix::impl
Chris@16: 
Chris@16: namespace boost { namespace phoenix
Chris@16: {
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(swap, impl::swap, 2)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(copy, impl::copy, 2)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(copy_backward, impl::copy_backward, 2)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(transform, impl::transform, 3)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(transform, impl::transform, 4)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(replace, impl::replace, 3)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(replace_if, impl::replace_if, 3)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(replace_copy, impl::replace_copy, 4)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(replace_copy_if, impl::replace_copy_if, 4)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(fill, impl::fill, 2)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(fill_n, impl::fill_n, 3)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(generate, impl::generate, 2)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(generate_n, impl::generate_n, 3)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(remove, impl::remove, 2)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(remove_if, impl::remove_if, 2)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(remove_copy, impl::remove_copy, 3)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(remove_copy_if, impl::remove_copy_if, 3)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(unique, impl::unique, 1)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(unique, impl::unique, 2)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(unique_copy, impl::unique_copy, 2)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(unique_copy, impl::unique_copy, 3)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(reverse, impl::reverse, 1)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(reverse_copy, impl::reverse_copy, 2)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(rotate, impl::rotate, 2)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(rotate_copy, impl::rotate_copy, 3)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(random_shuffle, impl::random_shuffle, 1)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(random_shuffle, impl::random_shuffle, 2)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(partition, impl::partition, 2)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(stable_partition, impl::stable_partition, 2)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(sort, impl::sort, 1)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(sort, impl::sort, 2)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(stable_sort, impl::stable_sort, 1)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(stable_sort, impl::stable_sort, 2)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(partial_sort, impl::partial_sort, 2)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(partial_sort, impl::partial_sort, 3)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(partial_sort_copy, impl::partial_sort_copy, 2)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(partial_sort_copy, impl::partial_sort_copy, 3)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(nth_element, impl::nth_element, 2)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(nth_element, impl::nth_element, 3)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(merge, impl::merge, 3)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(merge, impl::merge, 4)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(inplace_merge, impl::inplace_merge, 2)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(inplace_merge, impl::inplace_merge, 3)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(next_permutation, impl::next_permutation, 1)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(next_permutation, impl::next_permutation, 2)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(prev_permutation, impl::prev_permutation, 1)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(prev_permutation, impl::prev_permutation, 2)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(inner_product, impl::inner_product, 3)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(inner_product, impl::inner_product, 5)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(partial_sum, impl::partial_sum, 2)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(partial_sum, impl::partial_sum, 3)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(adjacent_difference, impl::adjacent_difference, 2)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(adjacent_difference, impl::adjacent_difference, 3)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(push_heap, impl::push_heap, 1)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(push_heap, impl::push_heap, 2)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(pop_heap, impl::pop_heap, 1)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(pop_heap, impl::pop_heap, 2)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(make_heap, impl::make_heap, 1)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(make_heap, impl::make_heap, 2)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(sort_heap, impl::sort_heap, 1)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(sort_heap, impl::sort_heap, 2)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(set_union, impl::set_union, 3)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(set_union, impl::set_union, 4)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(set_intersection, impl::set_intersection, 3)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(set_intersection, impl::set_intersection, 4)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(set_difference, impl::set_difference, 3)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(set_difference, impl::set_difference, 4)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(set_symmetric_difference, impl::set_symmetric_difference, 3)
Chris@16:     BOOST_PHOENIX_ADAPT_CALLABLE(set_symmetric_difference, impl::set_symmetric_difference, 4)
Chris@16: }}
Chris@16: 
Chris@16: #endif