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

#include <boost/core/enable_if.hpp>

#include <boost/core/is_same.hpp>

#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )

#include <utility> // std::forward

#endif

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

}

};

#ifdef BOOST_MSVC

// MSVC is bright enough to realise that the parameter rhs

// in operator==may be unused for some template argument types:

#pragma warning(push)

#pragma warning(disable:4100)

#endif

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

}

bool operator==(list5 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 ) &&

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

}

};

template<class A1, class A2, class A3, class A4, class A5, class A6> class list6: private storage6< A1, A2, A3, A4, A5, A6 >

{

private:

typedef storage6< A1, A2, A3, A4, A5, A6 > base_type;

public:

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

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_; }

A6 operator[] (boost::arg<6>) const { return base_type::a6_; }

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_; }

A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }

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_], a[base_type::a6_]);

}

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_], a[base_type::a6_]);

}

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_], a[base_type::a6_]);

}

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_], a[base_type::a6_]);

}

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

{

base_type::accept(v);

}

bool operator==(list6 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 ) &&

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

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

}

};

template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> class list7: private storage7< A1, A2, A3, A4, A5, A6, A7 >

{

private:

typedef storage7< A1, A2, A3, A4, A5, A6, A7 > base_type;

public:

list7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7 ): base_type( a1, a2, a3, a4, a5, a6, a7 ) {}

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_; }

A6 operator[] (boost::arg<6>) const { return base_type::a6_; }

A7 operator[] (boost::arg<7>) const { return base_type::a7_; }

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_; }

A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }

A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; }

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_], a[base_type::a6_], a[base_type::a7_]);

}

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_], a[base_type::a6_], a[base_type::a7_]);

}

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_], a[base_type::a6_], a[base_type::a7_]);

}

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_], a[base_type::a6_], a[base_type::a7_]);

}

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

{

base_type::accept(v);

}

bool operator==(list7 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 ) &&

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

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

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

}

};

template< class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 > class list8: private storage8< A1, A2, A3, A4, A5, A6, A7, A8 >

{

private:

typedef storage8< A1, A2, A3, A4, A5, A6, A7, A8 > base_type;

public:

list8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8 ): base_type( a1, a2, a3, a4, a5, a6, a7, a8 ) {}

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_; }

A6 operator[] (boost::arg<6>) const { return base_type::a6_; }

A7 operator[] (boost::arg<7>) const { return base_type::a7_; }

A8 operator[] (boost::arg<8>) const { return base_type::a8_; }

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_; }

A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }

A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; }

A8 operator[] (boost::arg<8> (*) ()) const { return base_type::a8_; }

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_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);

}

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_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);

}

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_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);

}

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_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);

}

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

{

base_type::accept(v);

}

bool operator==(list8 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 ) &&

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

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

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

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

}

};

template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> class list9: private storage9< A1, A2, A3, A4, A5, A6, A7, A8, A9 >

{

private:

typedef storage9< A1, A2, A3, A4, A5, A6, A7, A8, A9 > base_type;

public:

list9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9 ): base_type( a1, a2, a3, a4, a5, a6, a7, a8, a9 ) {}

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_; }

A6 operator[] (boost::arg<6>) const { return base_type::a6_; }

A7 operator[] (boost::arg<7>) const { return base_type::a7_; }

A8 operator[] (boost::arg<8>) const { return base_type::a8_; }

A9 operator[] (boost::arg<9>) const { return base_type::a9_; }

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_; }

A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }

A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; }

A8 operator[] (boost::arg<8> (*) ()) const { return base_type::a8_; }

A9 operator[] (boost::arg<9> (*) ()) const { return base_type::a9_; }

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_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);

}

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_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);

}

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_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);

}

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_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);

}

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

{

base_type::accept(v);

}

bool operator==(list9 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 ) &&

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

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

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

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

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

}

};

#ifdef BOOST_MSVC

#pragma warning(pop)

#endif

// bind_t

#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )

template< class A1 > class rrlist1

{

private:

A1 & a1_; // not A1&& because of msvc-10.0

public:

explicit rrlist1( A1 & a1 ): a1_( a1 ) {}

A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); } // not static_cast because of g++ 4.9

A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( 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

{

rrlist1<A1&> a( a1_ );

return b.eval( a );

}

template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const

{

rrlist1<A1&> a( a1_ );

return b.eval( a );

}

};

template< class A1, class A2 > class rrlist2

{

private:

A1 & a1_;

A2 & a2_;

public:

rrlist2( A1 & a1, A2 & a2 ): a1_( a1 ), a2_( a2 ) {}

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

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

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

A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( 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

{

rrlist2<A1&, A2&> a( a1_, a2_ );

return b.eval( a );

}

template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const

{

rrlist2<A1&, A2&> a( a1_, a2_ );

return b.eval( a );

}

};

template< class A1, class A2, class A3 > class rrlist3

{

private:

A1 & a1_;

A2 & a2_;

A3 & a3_;

public:

rrlist3( A1 & a1, A2 & a2, A3 & a3 ): a1_( a1 ), a2_( a2 ), a3_( a3 ) {}

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

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

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

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

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

A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( 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

{

rrlist3<A1&, A2&, A3&> a( a1_, a2_, a3_ );

return b.eval( a );

}

template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const

{

rrlist3<A1&, A2&, A3&> a( a1_, a2_, a3_ );

return b.eval( a );

}

};

template< class A1, class A2, class A3, class A4 > class rrlist4

{

private:

A1 & a1_;

A2 & a2_;

A3 & a3_;

A4 & a4_;

public:

rrlist4( A1 & a1, A2 & a2, A3 & a3, A4 & a4 ): a1_( a1 ), a2_( a2 ), a3_( a3 ), a4_( a4 ) {}

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

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

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

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

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

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

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

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