#ifndef BOOST_BIND_BIND_HPP_INCLUDED

#define BOOST_BIND_BIND_HPP_INCLUDED

// MS compatible compilers support #pragma once

#if defined(_MSC_VER) && (_MSC_VER >= 1020)

# pragma once

#endif

//

//  bind.hpp - binds function objects to arguments

//

//  Copyright (c) 2001-2004 Peter Dimov and Multi Media Ltd.

//  Copyright (c) 2001 David Abrahams

//  Copyright (c) 2005 Peter Dimov

//

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

//

//  See http://www.boost.org/libs/bind/bind.html for documentation.

//

#include <boost/config.hpp>

#include <boost/ref.hpp>

#include <boost/mem_fn.hpp>

#include <boost/type.hpp>

#include <boost/is_placeholder.hpp>

#include <boost/bind/arg.hpp>

#include <boost/detail/workaround.hpp>

#include <boost/visit_each.hpp>

// Borland-specific bug, visit_each() silently fails to produce code

#if defined(__BORLANDC__)

#  define BOOST_BIND_VISIT_EACH boost::visit_each

#else

#  define BOOST_BIND_VISIT_EACH visit_each

#endif

#include <boost/bind/storage.hpp>

#ifdef BOOST_MSVC

# pragma warning(push)

# pragma warning(disable: 4512) // assignment operator could not be generated

#endif

namespace boost

{

template<class T> class weak_ptr;

namespace _bi // implementation details

{

// result_traits

template<class R, class F> struct result_traits

{

    typedef R type;

};

#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)

struct unspecified {};

template<class F> struct result_traits<unspecified, F>

{

    typedef typename F::result_type type;

};

template<class F> struct result_traits< unspecified, reference_wrapper<F> >

{

    typedef typename F::result_type type;

};

#endif

// ref_compare

template<class T> bool ref_compare( T const & a, T const & b, long )

{

    return a == b;

}

template<int I> bool ref_compare( arg<I> const &, arg<I> const &, int )

{

    return true;

}

template<int I> bool ref_compare( arg<I> (*) (), arg<I> (*) (), int )

{

    return true;

}

template<class T> bool ref_compare( reference_wrapper<T> const & a, reference_wrapper<T> const & b, int )

{

    return a.get_pointer() == b.get_pointer();

}

// bind_t forward declaration for listN

template<class R, class F, class L> class bind_t;

template<class R, class F, class L> bool ref_compare( bind_t<R, F, L> const & a, bind_t<R, F, L> const & b, int )

{

    return a.compare( b );

}

// value

template<class T> class value

{

public:

    value(T const & t): t_(t) {}

    T & get() { return t_; }

    T const & get() const { return t_; }

    bool operator==(value const & rhs) const

    {

        return t_ == rhs.t_;

    }

private:

    T t_;

};

// ref_compare for weak_ptr

template<class T> bool ref_compare( value< weak_ptr<T> > const & a, value< weak_ptr<T> > const & b, int )

{

    return !(a.get() < b.get()) && !(b.get() < a.get());

}

// type

template<class T> class type {};

// unwrap

template<class F> struct unwrapper

{

    static inline F & unwrap( F & f, long )

    {

        return f;

    }

    template<class F2> static inline F2 & unwrap( reference_wrapper<F2> rf, int )

    {

        return rf.get();

    }

    template<class R, class T> static inline _mfi::dm<R, T> unwrap( R T::* pm, int )

    {

        return _mfi::dm<R, T>( pm );

    }

};

// listN

class list0

{

public:

    list0() {}

    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A &, long)

    {

        return unwrapper<F>::unwrap(f, 0)();

    }

    template<class R, class F, class A> R operator()(type<R>, F const & f, A &, long) const

    {

        return unwrapper<F const>::unwrap(f, 0)();

    }

    template<class F, class A> void operator()(type<void>, F & f, A &, int)

    {

        unwrapper<F>::unwrap(f, 0)();

    }

    template<class F, class A> void operator()(type<void>, F const & f, A &, int) const

    {

        unwrapper<F const>::unwrap(f, 0)();

    }

    template<class V> void accept(V &) const

    {

    }

    bool operator==(list0 const &) const

    {

        return true;

    }

};

template< class A1 > class list1: private storage1< A1 >

{

private:

    typedef storage1< A1 > base_type;

public:

    explicit list1( A1 a1 ): base_type( a1 ) {}

    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }

    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }

    template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }

    template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)

    {

        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_]);

    }

    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const

    {

        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_]);

    }

    template<class F, class A> void operator()(type<void>, F & f, A & a, int)

    {

        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_]);

    }

    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const

    {

        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_]);

    }

    template<class V> void accept(V & v) const

    {

        base_type::accept(v);

    }

    bool operator==(list1 const & rhs) const

    {

        return ref_compare(base_type::a1_, rhs.a1_, 0);

    }

};

struct logical_and;

struct logical_or;

template< class A1, class A2 > class list2: private storage2< A1, A2 >

{

private:

    typedef storage2< A1, A2 > base_type;

public:

    list2( A1 a1, A2 a2 ): base_type( a1, a2 ) {}

    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }

    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }

    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }

    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }

    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)

    {

        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);

    }

    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const

    {

        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);

    }

    template<class F, class A> void operator()(type<void>, F & f, A & a, int)

    {

        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);

    }

    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const

    {

        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);

    }

    template<class A> bool operator()( type<bool>, logical_and & /*f*/, A & a, int )

    {

        return a[ base_type::a1_ ] && a[ base_type::a2_ ];

    }

    template<class A> bool operator()( type<bool>, logical_and const & /*f*/, A & a, int ) const

    {

        return a[ base_type::a1_ ] && a[ base_type::a2_ ];

    }

    template<class A> bool operator()( type<bool>, logical_or & /*f*/, A & a, int )

    {

        return a[ base_type::a1_ ] || a[ base_type::a2_ ];

    }

    template<class A> bool operator()( type<bool>, logical_or const & /*f*/, A & a, int ) const

    {

        return a[ base_type::a1_ ] || a[ base_type::a2_ ];

    }

    template<class V> void accept(V & v) const

    {

        base_type::accept(v);

    }

    bool operator==(list2 const & rhs) const

    {

        return ref_compare(base_type::a1_, rhs.a1_, 0) && ref_compare(base_type::a2_, rhs.a2_, 0);

    }

};

template< class A1, class A2, class A3 > class list3: private storage3< A1, A2, A3 >

{

private:

    typedef storage3< A1, A2, A3 > base_type;

public:

    list3( A1 a1, A2 a2, A3 a3 ): base_type( a1, a2, a3 ) {}

    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }

    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }

    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }

    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }

    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }

    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }

    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)

    {

        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);

    }

    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const

    {

        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);

    }

    template<class F, class A> void operator()(type<void>, F & f, A & a, int)

    {

        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);

    }

    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const

    {

        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);

    }

    template<class V> void accept(V & v) const

    {

        base_type::accept(v);

    }

    bool operator==(list3 const & rhs) const

    {

        return

            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&

            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&

            ref_compare( base_type::a3_, rhs.a3_, 0 );

    }

};

template< class A1, class A2, class A3, class A4 > class list4: private storage4< A1, A2, A3, A4 >

{

private:

    typedef storage4< A1, A2, A3, A4 > base_type;

public:

    list4( A1 a1, A2 a2, A3 a3, A4 a4 ): base_type( a1, a2, a3, a4 ) {}

    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }

    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }

    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }

    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }

    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }

    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }

    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }

    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }

    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)

    {

        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);

    }

    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const

    {

        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);

    }

    template<class F, class A> void operator()(type<void>, F & f, A & a, int)

    {

        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);

    }

    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const

    {

        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);

    }

    template<class V> void accept(V & v) const

    {

        base_type::accept(v);

    }

    bool operator==(list4 const & rhs) const

    {

        return

            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&

            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&

            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&

            ref_compare( base_type::a4_, rhs.a4_, 0 );

    }

};

template< class A1, class A2, class A3, class A4, class A5 > class list5: private storage5< A1, A2, A3, A4, A5 >

{

private:

    typedef storage5< A1, A2, A3, A4, A5 > base_type;

public:

    list5( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5 ): base_type( a1, a2, a3, a4, a5 ) {}

    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }

    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }

    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }

    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }

    A5 operator[] (boost::arg<5>) const { return base_type::a5_; }

    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }

    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }

    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }

    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }

    A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }

    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)

    {

        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);

    }

    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const

    {

        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);

    }

    template<class F, class A> void operator()(type<void>, F & f, A & a, int)

    {

        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);

    }

    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const

    {

        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);

    }

    template<class V> void accept(V & v) const

    {

        base_type::accept(v);