// -- algorithm.hpp -- Boost Lambda Library -----------------------------------

// Copyright (C) 2002 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)

// Copyright (C) 2002 Gary Powell (gwpowell@hotmail.com)

//

// Distributed under the Boost Software License, Version 1.0. (See

// accompanying file LICENSE_1_0.txt or copy at

// http://www.boost.org/LICENSE_1_0.txt)

//

// For more information, see http://www.boost.org

#ifndef BOOST_LAMBDA_ALGORITHM_HPP

#define BOOST_LAMBDA_ALGORITHM_HPP

#include "boost/lambda/core.hpp"

#include <algorithm>

#include <iterator>  // for iterator_traits

#include <utility> // for std::pair

namespace boost {

  namespace lambda {

namespace ll {

// for_each ---------------------------------

struct for_each {

  template <class Args>

  struct sig { 

    typedef typename boost::remove_const<

        typename boost::tuples::element<3, Args>::type 

     >::type type; 

  };

  template <class A, class C>

  C

  operator()(A a, A b, C c) const

  { return ::std::for_each(a, b, c); }

};

// find  ---------------------------------

struct find {

  template <class Args>

  struct sig { 

    typedef typename boost::remove_const<

        typename boost::tuples::element<1, Args>::type 

     >::type type; 

  };

  template <class A, class C>

  A

  operator()(A a, A b, const C& c) const

  { return ::std::find(a, b, c); }

};

// find_if  ---------------------------------

struct find_if {

  template <class Args>

  struct sig { 

    typedef typename boost::remove_const<

        typename boost::tuples::element<1, Args>::type 

     >::type type; 

  };

  template <class A, class C>

  A

  operator()(A a, A b, C c) const

  { return ::std::find_if(a, b, c); }

};

// find_end  ---------------------------------

struct find_end {

  template <class Args>

  struct sig { 

    typedef typename boost::remove_const<

        typename boost::tuples::element<1, Args>::type 

     >::type type; 

  };

  template <class A, class C>

  A

  operator()(A a, A b, C c, C d) const

  { return ::std::find_end(a, b, c, d); }

  template <class A, class C, class E>

  A

  operator()(A a, A b, C c, C d, E e) const

  { return ::std::find_end(a, b, c, d, e); }

};

// find_first_of  ---------------------------------

struct find_first_of {

  template <class Args>

  struct sig { 

    typedef typename boost::remove_const<

        typename boost::tuples::element<1, Args>::type 

     >::type type; 

  };

  template <class A, class C>

  A

  operator()(A a, A b, C c, C d) const

  { return ::std::find_first_of(a, b, c, d); }

  template <class A, class C, class E>

  A

  operator()(A a, A b, C c, C d, E e) const

  { return ::std::find_first_of(a, b, c, d, e); }

};

// adjacent_find  ---------------------------------

struct adjacent_find {

  template <class Args>

  struct sig { 

    typedef typename boost::remove_const<

        typename boost::tuples::element<1, Args>::type 

     >::type type; 

  };

  template <class A>

  A

  operator()(A a, A b) const

  { return ::std::adjacent_find(a, b); }

  template <class A, class C>

  A

  operator()(A a, A b, C c) const

  { return ::std::adjacent_find(a, b, c); }

};

// count  ---------------------------------

struct count {

  template <class Args>

  struct sig { 

    typedef typename ::std::iterator_traits<

      typename boost::remove_const<

           typename boost::tuples::element<1, Args>::type

      >::type 

    >::difference_type type;

  };

  template <class A, class C >

  typename ::std::iterator_traits<A>::difference_type

  operator()(A a, A b, const C& c) const

  { return ::std::count(a, b, c); }

};

// count_if  ---------------------------------

struct count_if {

  template <class Args>

  struct sig { 

    typedef typename ::std::iterator_traits<

     typename boost::remove_const<

           typename boost::tuples::element<1, Args>::type

       >::type

    >::difference_type type;

  };

  template <class A, class C >

  typename ::std::iterator_traits<A>::difference_type

  operator()(A a, A b, C c) const

  { return ::std::count_if(a, b, c); }

};

// mismatch  ---------------------------------

struct mismatch {

  template <class Args>

  struct sig { 

    typedef typename boost::remove_const<

        typename boost::tuples::element<1, Args>::type

     >::type element1_type; 

    typedef typename boost::remove_const<

        typename boost::tuples::element<3, Args>::type

     >::type element2_type; 

    typedef ::std::pair< element1_type, element2_type > type;

   };

  template <class A, class C >

  ::std::pair<A,C>

  operator()(A a, A b, C c) const

  { return ::std::mismatch(a, b, c); }

  template <class A, class C, class D>

  ::std::pair<A,C>

  operator()(A a, A b, C c, D d) const

  { return ::std::mismatch(a, b, c, d); }

};

// equal  ---------------------------------

struct equal {

  template <class Args>

  struct sig { 

    typedef bool type;

  };

  template <class A, class C >

  bool

  operator()(A a, A b, C c) const

  { return ::std::equal(a, b, c); }

  template <class A, class C, class D>

  bool

  operator()(A a, A b, C c, D d) const

  { return ::std::equal(a, b, c, d); }

};

// search --------------------------------

struct search {

  template <class Args>

  struct sig { 

    typedef typename boost::remove_const<

        typename boost::tuples::element<1, Args>::type

     >::type type; 

  };

  template <class A, class C>

  A

  operator()(A a, A b, C c, C d) const

  { return std::search(a, b, c, d);}

  template <class A, class C, class E>

  A

  operator()(A a, A b, C c, C d, E e) const

  { return std::search(a, b, c, d, e);}

};

// copy  ---------------------------------

struct copy {

  template <class Args>

  struct sig { 

    typedef typename boost::remove_const<

        typename boost::tuples::element<3, Args>::type 

     >::type type; 

  };

  template <class A, class C>

  C

  operator()(A a, A b, C c) const

  { return ::std::copy(a, b, c); }

};

// copy_backward  ---------------------------------

struct copy_backward {

  template <class Args>

  struct sig { 

    typedef typename boost::remove_const<

        typename boost::tuples::element<3, Args>::type 

     >::type type; 

  };

  template <class A, class C>

  C

  operator()(A a, A b, C c) const

  { return ::std::copy_backward(a, b, c); }

};

// swap  ---------------------------------

struct swap {

  template <class Args>

  struct sig { 

    typedef void type; 

  };

  template <class A>

  void

  operator()(A a, A b) const

  { ::std::swap(a, b); }

};

// swap_ranges  ---------------------------------

struct swap_ranges {

  template <class Args>

  struct sig { 

    typedef typename boost::remove_const<

        typename boost::tuples::element<3, Args>::type 

     >::type type; 

  };

  template <class A, class C>

  C

  operator()(A a, A b, C c) const

  { return ::std::swap_ranges(a, b, c); }

};

// iter_swap  ---------------------------------

struct iter_swap {

  template <class Args>

  struct sig { 

     typedef void type; 

  };

  template <class A>

  void 

  operator()(A a, A b) const

  { ::std::iter_swap(a, b); }

};

// transform --------------------------------

struct transform {

  template <class Args>

  struct sig { 

    typedef typename boost::remove_const<

        typename boost::tuples::element<

          boost::tuples::length<Args>::value - 2, 

          Args

      >::type

     >::type type; 

  };

  template <class A, class C, class D>

  C

  operator()(A a, A b, C c, D d) const

  { return std::transform(a, b, c, d);}

  template <class A, class C, class D, class E>

  D

  operator()(A a, A b, C c, D d, E e) const

  { return std::transform(a, b, c, d, e);}

};

// replace  ---------------------------------

struct replace {

  template <class Args>

  struct sig {

    typedef void type;

  };

  template <class A, class C>

  void

  operator()(A a, A b, const C& c, const C& d) const

  { ::std::replace(a, b, c, d); }

};

// replace_if  ---------------------------------

struct replace_if {

  template <class Args>

  struct sig {

    typedef void type;

  };

  template <class A, class C, class D>

  void

  operator()(A a, A b, C c, const D& d) const

  { ::std::replace_if(a, b, c, d); }

};

// replace_copy  ---------------------------------

struct replace_copy {

 template <class Args>

  struct sig { 

    typedef typename boost::remove_const<

        typename boost::tuples::element<3, Args>::type 

     >::type type; 

  };

  template <class A, class C, class D>

  C

  operator()(A a, A b, C c, const D& d, const D& e) const

  { return ::std::replace_copy(a, b, c, d, e); }

};

// replace_copy_if  ---------------------------------

struct replace_copy_if {

 template <class Args>

  struct sig { 

    typedef typename boost::remove_const<

        typename boost::tuples::element<3, Args>::type 

     >::type type; 

  };

  template <class A, class C, class D, class E>

  C

  operator()(A a, A b, C c, D d, const E& e) const

  { return ::std::replace_copy_if(a, b, c, d, e); }

};

// fill  ---------------------------------

struct fill {

  template <class Args>

  struct sig { 

     typedef void type; 

  };

  template <class A, class C>

  void 

  operator()(A a, A b, const C& c) const

  { ::std::fill(a, b, c); }

};

// fill_n  ---------------------------------

struct fill_n {

  template <class Args>

  struct sig { 

     typedef void type; 

  };

  template <class A, class B, class C>

  void 

  operator()(A a, B b, const C& c) const

  { ::std::fill_n(a, b, c); }

};

// generate  ---------------------------------

struct generate {

  template <class Args>

  struct sig { 

     typedef void type; 

  };

  template <class A, class C>

  void 

  operator()(A a, A b, C c) const

  { ::std::generate(a, b, c); }

};

// generate_n  ---------------------------------

struct generate_n {

  template <class Args>

  struct sig { 

     typedef void type; 

  };

  template <class A, class B, class C>

  void 

  operator()(A a, B b, C c) const

  { ::std::generate_n(a, b, c); }

};

// remove  ---------------------------------

struct remove {

  template <class Args>

  struct sig { 

    typedef typename boost::remove_const<

        typename boost::tuples::element<1, Args>::type 

     >::type type; 

  };

  template <class A, class C >

  A

  operator()(A a, A b, const C& c) const

  { return ::std::remove(a, b, c); }

};

// remove_if  ---------------------------------

struct remove_if {

  template <class Args>

  struct sig { 

    typedef typename boost::remove_const<

       typename boost::tuples::element<1, Args>::type

     >::type type;