Symaptic: os/ossrv/ossrv_pub/boost_apis/boost/bind.hpp@260cb5ec6c19

     1 #ifndef BOOST_BIND_HPP_INCLUDED

     2 #define BOOST_BIND_HPP_INCLUDED

     4 // MS compatible compilers support #pragma once

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

     7 # pragma once

     8 #endif

    10 //

    11 //  bind.hpp - binds function objects to arguments

    12 //

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

    14 //  Copyright (c) 2001 David Abrahams

    15 //  Copyright (c) 2005 Peter Dimov

    16 //

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

    18 // accompanying file LICENSE_1_0.txt or copy at

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

    20 //

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

    22 //

    24 #include <boost/config.hpp>

    25 #include <boost/ref.hpp>

    26 #include <boost/mem_fn.hpp>

    27 #include <boost/type.hpp>

    28 #include <boost/bind/arg.hpp>

    29 #include <boost/detail/workaround.hpp>

    30 #include <boost/visit_each.hpp>

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

    34 #if defined(__BORLANDC__)

    35 #  define BOOST_BIND_VISIT_EACH boost::visit_each

    36 #else

    37 #  define BOOST_BIND_VISIT_EACH visit_each

    38 #endif

    40 #include <boost/bind/storage.hpp>

    42 #ifdef BOOST_MSVC

    43 # pragma warning(push)

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

    45 #endif

    47 namespace boost

    48 {

    50 namespace _bi // implementation details

    51 {

    53 // result_traits

    55 template<class R, class F> struct result_traits

    56 {

    57     typedef R type;

    58 };

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

    62 struct unspecified {};

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

    65 {

    66     typedef typename F::result_type type;

    67 };

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

    70 {

    71     typedef typename F::result_type type;

    72 };

    74 #endif

    76 // ref_compare

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

    79 {

    80     return a == b;

    81 }

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

    84 {

    85     return true;

    86 }

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

    89 {

    90     return true;

    91 }

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

    94 {

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

    96 }

    98 // bind_t forward declaration for listN

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

   102 // value

   104 template<class T> class value

   105 {

   106 public:

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

   110     T & get() { return t_; }

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

   113     bool operator==(value const & rhs) const

   114     {

   115         return t_ == rhs.t_;

   116     }

   118 private:

   120     T t_;

   121 };

   123 // type

   125 template<class T> class type {};

   127 // unwrap

   129 template<class F> struct unwrapper

   130 {

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

   132     {

   133         return f;

   134     }

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

   137     {

   138         return rf.get();

   139     }

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

   142     {

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

   144     }

   145 };

   147 // listN

   149 class list0

   150 {

   151 public:

   153     list0() {}

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

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

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

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

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

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

   166     {

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

   168     }

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

   171     {

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

   173     }

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

   176     {

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

   178     }

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

   181     {

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

   183     }

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

   186     {

   187     }

   189     bool operator==(list0 const &) const

   190     {

   191         return true;

   192     }

   193 };

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

   196 {

   197 private:

   199     typedef storage1< A1 > base_type;

   201 public:

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

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

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

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

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

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

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

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

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

   220     {

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

   222     }

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

   225     {

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

   227     }

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

   230     {

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

   232     }

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

   235     {

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

   237     }

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

   240     {

   241         base_type::accept(v);

   242     }

   244     bool operator==(list1 const & rhs) const

   245     {

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

   247     }

   248 };

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

   251 {

   252 private:

   254     typedef storage2< A1, A2 > base_type;

   256 public:

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

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

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

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

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

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

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

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

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

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

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

   277     {

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

   279     }

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

   282     {

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

   284     }

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

   287     {

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

   289     }

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

   292     {

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

   294     }

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

   297     {

   298         base_type::accept(v);

   299     }

   301     bool operator==(list2 const & rhs) const

   302     {

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

   304     }

   305 };

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

   308 {

   309 private:

   311     typedef storage3< A1, A2, A3 > base_type;

   313 public:

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

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

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

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

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

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

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

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

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

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

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

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

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

   336     {

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

   338     }

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

   341     {

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

   343     }

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

   346     {

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

   348     }

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

   351     {

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

   353     }

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

   356     {

   357         base_type::accept(v);

   358     }

   360     bool operator==(list3 const & rhs) const

   361     {

   362         return

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

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

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

   367     }

   368 };

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

   371 {

   372 private:

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

   376 public:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   401     {

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

   403     }

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

   406     {

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

   408     }

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

   411     {

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

   413     }

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

   416     {

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

   418     }

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

   421     {

   422         base_type::accept(v);

   423     }

   425     bool operator==(list4 const & rhs) const

   426     {

   427         return

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

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

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

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

   433     }

   434 };

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

   437 {

   438 private:

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

   442 public:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   469     {

   470         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_]);

   471     }

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

   474     {

   475         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_]);

   476     }

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

   479     {

   480         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_]);

   481     }

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

   484     {

   485         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_]);

   486     }

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

   489     {

   490         base_type::accept(v);

   491     }

   493     bool operator==(list5 const & rhs) const

   494     {

   495         return

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

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

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

   500             ref_compare( base_type::a4_, rhs.a4_, 0 ) &&

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

   502     }

   503 };

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

   506 {

   507 private:

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

   511 public:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   540     {

   541         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_]);

   542     }

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

   545     {

   546         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_]);

   547     }

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

   550     {

   551         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_]);

   552     }

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

   555     {

   556         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_]);

   557     }

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

   560     {

   561         base_type::accept(v);

   562     }

   564     bool operator==(list6 const & rhs) const

   565     {

   566         return

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

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

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

   571             ref_compare( base_type::a4_, rhs.a4_, 0 ) &&

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

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

   574     }

   575 };

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

   578 {

   579 private:

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

   583 public:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   614     {

   615         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_]);

   616     }

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

   619     {

   620         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_]);

   621     }

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

   624     {

   625         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_]);

   626     }

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

   629     {

   630         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_]);

   631     }

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

   634     {

   635         base_type::accept(v);

   636     }

   638     bool operator==(list7 const & rhs) const

   639     {

   640         return

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

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

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

   645             ref_compare( base_type::a4_, rhs.a4_, 0 ) &&

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

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

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

   649     }

   650 };

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

   653 {

   654 private:

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

   658 public:

   660     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 ) {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   691     {

   692         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_]);

   693     }

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

   696     {

   697         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_]);

   698     }

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

   701     {

   702         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_]);

   703     }

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

   706     {

   707         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_]);

   708     }

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

   711     {

   712         base_type::accept(v);

   713     }

   715     bool operator==(list8 const & rhs) const

   716     {

   717         return

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

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

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

   722             ref_compare( base_type::a4_, rhs.a4_, 0 ) &&

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

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

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

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

   727     }

   728 };

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

   731 {

   732 private:

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

   736 public:

   738     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 ) {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   771     {

   772         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_]);

   773     }

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

   776     {

   777         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_]);

   778     }

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

   781     {

   782         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_]);

   783     }

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

   786     {

   787         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_]);

   788     }

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

   791     {

   792         base_type::accept(v);

   793     }

   795     bool operator==(list9 const & rhs) const

   796     {

   797         return

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

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

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

   802             ref_compare( base_type::a4_, rhs.a4_, 0 ) &&

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

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

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

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

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

   808     }

   809 };

   811 // bind_t

   813 #ifndef BOOST_NO_VOID_RETURNS

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

   816 {

   817 public:

   819     typedef bind_t this_type;

   821     bind_t(F f, L const & l): f_(f), l_(l) {}

   823 #define BOOST_BIND_RETURN return

   824 #include <boost/bind/bind_template.hpp>

   825 #undef BOOST_BIND_RETURN

   827 };

   829 #else

   831 template<class R> struct bind_t_generator

   832 {

   834 template<class F, class L> class implementation

   835 {

   836 public:

   838     typedef implementation this_type;

   840     implementation(F f, L const & l): f_(f), l_(l) {}

   842 #define BOOST_BIND_RETURN return

   843 #include <boost/bind/bind_template.hpp>

   844 #undef BOOST_BIND_RETURN

   846 };

   848 };

   850 template<> struct bind_t_generator<void>

   851 {

   853 template<class F, class L> class implementation

   854 {

   855 private:

   857     typedef void R;

   859 public:

   861     typedef implementation this_type;

   863     implementation(F f, L const & l): f_(f), l_(l) {}

   865 #define BOOST_BIND_RETURN

   866 #include <boost/bind/bind_template.hpp>

   867 #undef BOOST_BIND_RETURN

   869 };

   871 };

   873 template<class R2, class F, class L> class bind_t: public bind_t_generator<R2>::BOOST_NESTED_TEMPLATE implementation<F, L>

   874 {

   875 public:

   877     bind_t(F f, L const & l): bind_t_generator<R2>::BOOST_NESTED_TEMPLATE implementation<F, L>(f, l) {}

   879 };

   881 #endif

   883 // function_equal

   885 #ifndef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP

   887 // put overloads in _bi, rely on ADL

   889 # ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING

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

   892 {

   893     return a.compare(b);

   894 }

   896 # else

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

   899 {

   900     return a.compare(b);

   901 }

   903 # endif // #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING

   905 #else // BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP

   907 // put overloads in boost

   909 } // namespace _bi

   911 # ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING

   913 template<class R, class F, class L> bool function_equal( _bi::bind_t<R, F, L> const & a, _bi::bind_t<R, F, L> const & b )

   914 {

   915     return a.compare(b);

   916 }

   918 # else

   920 template<class R, class F, class L> bool function_equal_impl( _bi::bind_t<R, F, L> const & a, _bi::bind_t<R, F, L> const & b, int )

   921 {

   922     return a.compare(b);

   923 }

   925 # endif // #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING

   927 namespace _bi

   928 {

   930 #endif // BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP

   932 // add_value

   934 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) || (__SUNPRO_CC >= 0x530)

   936 template<class T> struct add_value

   937 {

   938     typedef _bi::value<T> type;

   939 };

   941 template<class T> struct add_value< value<T> >

   942 {

   943     typedef _bi::value<T> type;

   944 };

   946 template<class T> struct add_value< reference_wrapper<T> >

   947 {

   948     typedef reference_wrapper<T> type;

   949 };

   951 template<int I> struct add_value< arg<I> >

   952 {

   953     typedef boost::arg<I> type;

   954 };

   956 template<int I> struct add_value< arg<I> (*) () >

   957 {

   958     typedef boost::arg<I> (*type) ();

   959 };

   961 template<class R, class F, class L> struct add_value< bind_t<R, F, L> >

   962 {

   963     typedef bind_t<R, F, L> type;

   964 };

   966 #else

   968 template<int I> struct _avt_0;

   970 template<> struct _avt_0<1>

   971 {

   972     template<class T> struct inner

   973     {

   974         typedef T type;

   975     };

   976 };

   978 template<> struct _avt_0<2>

   979 {

   980     template<class T> struct inner

   981     {

   982         typedef value<T> type;

   983     };

   984 };

   986 typedef char (&_avt_r1) [1];

   987 typedef char (&_avt_r2) [2];

   989 template<class T> _avt_r1 _avt_f(value<T>);

   990 template<class T> _avt_r1 _avt_f(reference_wrapper<T>);

   991 template<int I> _avt_r1 _avt_f(arg<I>);

   992 template<int I> _avt_r1 _avt_f(arg<I> (*) ());

   993 template<class R, class F, class L> _avt_r1 _avt_f(bind_t<R, F, L>);

   995 _avt_r2 _avt_f(...);

   997 template<class T> struct add_value

   998 {

   999     static T t();

  1000     typedef typename _avt_0<sizeof(_avt_f(t()))>::template inner<T>::type type;

  1001 };

  1003 #endif

  1005 // list_av_N

  1007 template<class A1> struct list_av_1

  1008 {

  1009     typedef typename add_value<A1>::type B1;

  1010     typedef list1<B1> type;

  1011 };

  1013 template<class A1, class A2> struct list_av_2

  1014 {

  1015     typedef typename add_value<A1>::type B1;

  1016     typedef typename add_value<A2>::type B2;

  1017     typedef list2<B1, B2> type;

  1018 };

  1020 template<class A1, class A2, class A3> struct list_av_3

  1021 {

  1022     typedef typename add_value<A1>::type B1;

  1023     typedef typename add_value<A2>::type B2;

  1024     typedef typename add_value<A3>::type B3;

  1025     typedef list3<B1, B2, B3> type;

  1026 };

  1028 template<class A1, class A2, class A3, class A4> struct list_av_4

  1029 {

  1030     typedef typename add_value<A1>::type B1;

  1031     typedef typename add_value<A2>::type B2;

  1032     typedef typename add_value<A3>::type B3;

  1033     typedef typename add_value<A4>::type B4;

  1034     typedef list4<B1, B2, B3, B4> type;

  1035 };

  1037 template<class A1, class A2, class A3, class A4, class A5> struct list_av_5

  1038 {

  1039     typedef typename add_value<A1>::type B1;

  1040     typedef typename add_value<A2>::type B2;

  1041     typedef typename add_value<A3>::type B3;

  1042     typedef typename add_value<A4>::type B4;

  1043     typedef typename add_value<A5>::type B5;

  1044     typedef list5<B1, B2, B3, B4, B5> type;

  1045 };

  1047 template<class A1, class A2, class A3, class A4, class A5, class A6> struct list_av_6

  1048 {

  1049     typedef typename add_value<A1>::type B1;

  1050     typedef typename add_value<A2>::type B2;

  1051     typedef typename add_value<A3>::type B3;

  1052     typedef typename add_value<A4>::type B4;

  1053     typedef typename add_value<A5>::type B5;

  1054     typedef typename add_value<A6>::type B6;

  1055     typedef list6<B1, B2, B3, B4, B5, B6> type;

  1056 };

  1058 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct list_av_7

  1059 {

  1060     typedef typename add_value<A1>::type B1;

  1061     typedef typename add_value<A2>::type B2;

  1062     typedef typename add_value<A3>::type B3;

  1063     typedef typename add_value<A4>::type B4;

  1064     typedef typename add_value<A5>::type B5;

  1065     typedef typename add_value<A6>::type B6;

  1066     typedef typename add_value<A7>::type B7;

  1067     typedef list7<B1, B2, B3, B4, B5, B6, B7> type;

  1068 };

  1070 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct list_av_8

  1071 {

  1072     typedef typename add_value<A1>::type B1;

  1073     typedef typename add_value<A2>::type B2;

  1074     typedef typename add_value<A3>::type B3;

  1075     typedef typename add_value<A4>::type B4;

  1076     typedef typename add_value<A5>::type B5;

  1077     typedef typename add_value<A6>::type B6;

  1078     typedef typename add_value<A7>::type B7;

  1079     typedef typename add_value<A8>::type B8;

  1080     typedef list8<B1, B2, B3, B4, B5, B6, B7, B8> type;

  1081 };

  1083 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> struct list_av_9

  1084 {

  1085     typedef typename add_value<A1>::type B1;

  1086     typedef typename add_value<A2>::type B2;

  1087     typedef typename add_value<A3>::type B3;

  1088     typedef typename add_value<A4>::type B4;

  1089     typedef typename add_value<A5>::type B5;

  1090     typedef typename add_value<A6>::type B6;

  1091     typedef typename add_value<A7>::type B7;

  1092     typedef typename add_value<A8>::type B8;

  1093     typedef typename add_value<A9>::type B9;

  1094     typedef list9<B1, B2, B3, B4, B5, B6, B7, B8, B9> type;

  1095 };

  1097 // operator!

  1099 struct logical_not

  1100 {

  1101     template<class V> bool operator()(V const & v) const { return !v; }

  1102 };

  1104 template<class R, class F, class L>

  1105     bind_t< bool, logical_not, list1< bind_t<R, F, L> > >

  1106     operator! (bind_t<R, F, L> const & f)

  1107 {

  1108     typedef list1< bind_t<R, F, L> > list_type;

  1109     return bind_t<bool, logical_not, list_type> ( logical_not(), list_type(f) );

  1110 }

  1112 // relational operators

  1114 #define BOOST_BIND_OPERATOR( op, name ) \

  1115 \

  1116 struct name \

  1117 { \

  1118     template<class V, class W> bool operator()(V const & v, W const & w) const { return v op w; } \

  1119 }; \

  1120  \

  1121 template<class R, class F, class L, class A2> \

  1122     bind_t< bool, name, list2< bind_t<R, F, L>, typename add_value<A2>::type > > \

  1123     operator op (bind_t<R, F, L> const & f, A2 a2) \

  1124 { \

  1125     typedef typename add_value<A2>::type B2; \

  1126     typedef list2< bind_t<R, F, L>, B2> list_type; \

  1127     return bind_t<bool, name, list_type> ( name(), list_type(f, a2) ); \

  1128 }

  1130 BOOST_BIND_OPERATOR( ==, equal )

  1131 BOOST_BIND_OPERATOR( !=, not_equal )

  1133 BOOST_BIND_OPERATOR( <, less )

  1134 BOOST_BIND_OPERATOR( <=, less_equal )

  1136 BOOST_BIND_OPERATOR( >, greater )

  1137 BOOST_BIND_OPERATOR( >=, greater_equal )

  1139 #undef BOOST_BIND_OPERATOR

  1141 #if defined(__GNUC__) && BOOST_WORKAROUND(__GNUC__, < 3)

  1143 // resolve ambiguity with rel_ops

  1145 #define BOOST_BIND_OPERATOR( op, name ) \

  1146 \

  1147 template<class R, class F, class L> \

  1148     bind_t< bool, name, list2< bind_t<R, F, L>, bind_t<R, F, L> > > \

  1149     operator op (bind_t<R, F, L> const & f, bind_t<R, F, L> const & g) \

  1150 { \

  1151     typedef list2< bind_t<R, F, L>, bind_t<R, F, L> > list_type; \

  1152     return bind_t<bool, name, list_type> ( name(), list_type(f, g) ); \

  1153 }

  1155 BOOST_BIND_OPERATOR( !=, not_equal )

  1156 BOOST_BIND_OPERATOR( <=, less_equal )

  1157 BOOST_BIND_OPERATOR( >, greater )

  1158 BOOST_BIND_OPERATOR( >=, greater_equal )

  1160 #endif

  1162 // visit_each, ADL

  1164 #if !defined( BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP ) && !defined( __BORLANDC__ ) \

  1165    && !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)

  1167 template<class V, class T> void visit_each( V & v, value<T> const & t, int )

  1168 {

  1169     using boost::visit_each;

  1170     BOOST_BIND_VISIT_EACH( v, t.get(), 0 );

  1171 }

  1173 template<class V, class R, class F, class L> void visit_each( V & v, bind_t<R, F, L> const & t, int )

  1174 {

  1175     t.accept( v );

  1176 }

  1178 #endif

  1180 } // namespace _bi

  1182 // visit_each, no ADL

  1184 #if defined( BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP ) || defined( __BORLANDC__ ) \

  1185   || (defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)

  1187 template<class V, class T> void visit_each( V & v, _bi::value<T> const & t, int )

  1188 {

  1189     BOOST_BIND_VISIT_EACH( v, t.get(), 0 );

  1190 }

  1192 template<class V, class R, class F, class L> void visit_each( V & v, _bi::bind_t<R, F, L> const & t, int )

  1193 {

  1194     t.accept( v );

  1195 }

  1197 #endif

  1199 // bind

  1201 #ifndef BOOST_BIND

  1202 #define BOOST_BIND bind

  1203 #endif

  1205 // generic function objects

  1207 template<class R, class F>

  1208     _bi::bind_t<R, F, _bi::list0>

  1209     BOOST_BIND(F f)

  1210 {

  1211     typedef _bi::list0 list_type;

  1212     return _bi::bind_t<R, F, list_type> (f, list_type());

  1213 }

  1215 template<class R, class F, class A1>

  1216     _bi::bind_t<R, F, typename _bi::list_av_1<A1>::type>

  1217     BOOST_BIND(F f, A1 a1)

  1218 {

  1219     typedef typename _bi::list_av_1<A1>::type list_type;

  1220     return _bi::bind_t<R, F, list_type> (f, list_type(a1));

  1221 }

  1223 template<class R, class F, class A1, class A2>

  1224     _bi::bind_t<R, F, typename _bi::list_av_2<A1, A2>::type>

  1225     BOOST_BIND(F f, A1 a1, A2 a2)

  1226 {

  1227     typedef typename _bi::list_av_2<A1, A2>::type list_type;

  1228     return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));

  1229 }

  1231 template<class R, class F, class A1, class A2, class A3>

  1232     _bi::bind_t<R, F, typename _bi::list_av_3<A1, A2, A3>::type>

  1233     BOOST_BIND(F f, A1 a1, A2 a2, A3 a3)

  1234 {

  1235     typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;

  1236     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));

  1237 }

  1239 template<class R, class F, class A1, class A2, class A3, class A4>

  1240     _bi::bind_t<R, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>

  1241     BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4)

  1242 {

  1243     typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;

  1244     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));

  1245 }

  1247 template<class R, class F, class A1, class A2, class A3, class A4, class A5>

  1248     _bi::bind_t<R, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>

  1249     BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)

  1250 {

  1251     typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;

  1252     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));

  1253 }

  1255 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6>

  1256     _bi::bind_t<R, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>

  1257     BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)

  1258 {

  1259     typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;

  1260     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));

  1261 }

  1263 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>

  1264     _bi::bind_t<R, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>

  1265     BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)

  1266 {

  1267     typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;

  1268     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));

  1269 }

  1271 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>

  1272     _bi::bind_t<R, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>

  1273     BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)

  1274 {

  1275     typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;

  1276     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));

  1277 }

  1279 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>

  1280     _bi::bind_t<R, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>

  1281     BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)

  1282 {

  1283     typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;

  1284     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));

  1285 }

  1287 // generic function objects, alternative syntax

  1289 template<class R, class F>

  1290     _bi::bind_t<R, F, _bi::list0>

  1291     BOOST_BIND(boost::type<R>, F f)

  1292 {

  1293     typedef _bi::list0 list_type;

  1294     return _bi::bind_t<R, F, list_type> (f, list_type());

  1295 }

  1297 template<class R, class F, class A1>

  1298     _bi::bind_t<R, F, typename _bi::list_av_1<A1>::type>

  1299     BOOST_BIND(boost::type<R>, F f, A1 a1)

  1300 {

  1301     typedef typename _bi::list_av_1<A1>::type list_type;

  1302     return _bi::bind_t<R, F, list_type> (f, list_type(a1));

  1303 }

  1305 template<class R, class F, class A1, class A2>

  1306     _bi::bind_t<R, F, typename _bi::list_av_2<A1, A2>::type>

  1307     BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2)

  1308 {

  1309     typedef typename _bi::list_av_2<A1, A2>::type list_type;

  1310     return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));

  1311 }

  1313 template<class R, class F, class A1, class A2, class A3>

  1314     _bi::bind_t<R, F, typename _bi::list_av_3<A1, A2, A3>::type>

  1315     BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3)

  1316 {

  1317     typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;

  1318     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));

  1319 }

  1321 template<class R, class F, class A1, class A2, class A3, class A4>

  1322     _bi::bind_t<R, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>

  1323     BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4)

  1324 {

  1325     typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;

  1326     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));

  1327 }

  1329 template<class R, class F, class A1, class A2, class A3, class A4, class A5>

  1330     _bi::bind_t<R, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>

  1331     BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)

  1332 {

  1333     typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;

  1334     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));

  1335 }

  1337 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6>

  1338     _bi::bind_t<R, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>

  1339     BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)

  1340 {

  1341     typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;

  1342     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));

  1343 }

  1345 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>

  1346     _bi::bind_t<R, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>

  1347     BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)

  1348 {

  1349     typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;

  1350     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));

  1351 }

  1353 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>

  1354     _bi::bind_t<R, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>

  1355     BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)

  1356 {

  1357     typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;

  1358     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));

  1359 }

  1361 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>

  1362     _bi::bind_t<R, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>

  1363     BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)

  1364 {

  1365     typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;

  1366     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));

  1367 }

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

  1371 // adaptable function objects

  1373 template<class F>

  1374     _bi::bind_t<_bi::unspecified, F, _bi::list0>

  1375     BOOST_BIND(F f)

  1376 {

  1377     typedef _bi::list0 list_type;

  1378     return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type());

  1379 }

  1381 template<class F, class A1>

  1382     _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_1<A1>::type>

  1383     BOOST_BIND(F f, A1 a1)

  1384 {

  1385     typedef typename _bi::list_av_1<A1>::type list_type;

  1386     return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type(a1));

  1387 }

  1389 template<class F, class A1, class A2>

  1390     _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_2<A1, A2>::type>

  1391     BOOST_BIND(F f, A1 a1, A2 a2)

  1392 {

  1393     typedef typename _bi::list_av_2<A1, A2>::type list_type;

  1394     return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type(a1, a2));

  1395 }

  1397 template<class F, class A1, class A2, class A3>

  1398     _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_3<A1, A2, A3>::type>

  1399     BOOST_BIND(F f, A1 a1, A2 a2, A3 a3)

  1400 {

  1401     typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;

  1402     return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3));

  1403 }

  1405 template<class F, class A1, class A2, class A3, class A4>

  1406     _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>

  1407     BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4)

  1408 {

  1409     typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;

  1410     return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4));

  1411 }

  1413 template<class F, class A1, class A2, class A3, class A4, class A5>

  1414     _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>

  1415     BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)

  1416 {

  1417     typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;

  1418     return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5));

  1419 }

  1421 template<class F, class A1, class A2, class A3, class A4, class A5, class A6>

  1422     _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>

  1423     BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)

  1424 {

  1425     typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;

  1426     return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));

  1427 }

  1429 template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>

  1430     _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>

  1431     BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)

  1432 {

  1433     typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;

  1434     return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));

  1435 }

  1437 template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>

  1438     _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>

  1439     BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)

  1440 {

  1441     typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;

  1442     return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));

  1443 }

  1445 template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>

  1446     _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>

  1447     BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)

  1448 {

  1449     typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;

  1450     return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));

  1451 }

  1453 #endif // !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)

  1455 // function pointers

  1457 #define BOOST_BIND_CC

  1458 #define BOOST_BIND_ST

  1460 #include <boost/bind/bind_cc.hpp>

  1462 #undef BOOST_BIND_CC

  1463 #undef BOOST_BIND_ST

  1465 #ifdef BOOST_BIND_ENABLE_STDCALL

  1467 #define BOOST_BIND_CC __stdcall

  1468 #define BOOST_BIND_ST

  1470 #include <boost/bind/bind_cc.hpp>

  1472 #undef BOOST_BIND_CC

  1473 #undef BOOST_BIND_ST

  1475 #endif

  1477 #ifdef BOOST_BIND_ENABLE_FASTCALL

  1479 #define BOOST_BIND_CC __fastcall

  1480 #define BOOST_BIND_ST

  1482 #include <boost/bind/bind_cc.hpp>

  1484 #undef BOOST_BIND_CC

  1485 #undef BOOST_BIND_ST

  1487 #endif

  1489 #ifdef BOOST_BIND_ENABLE_PASCAL

  1491 #define BOOST_BIND_ST pascal

  1492 #define BOOST_BIND_CC

  1494 #include <boost/bind/bind_cc.hpp>

  1496 #undef BOOST_BIND_ST

  1497 #undef BOOST_BIND_CC

  1499 #endif

  1501 // member function pointers

  1503 #define BOOST_BIND_MF_NAME(X) X

  1504 #define BOOST_BIND_MF_CC

  1506 #include <boost/bind/bind_mf_cc.hpp>

  1508 #undef BOOST_BIND_MF_NAME

  1509 #undef BOOST_BIND_MF_CC

  1511 #ifdef BOOST_MEM_FN_ENABLE_CDECL

  1513 #define BOOST_BIND_MF_NAME(X) X##_cdecl

  1514 #define BOOST_BIND_MF_CC __cdecl

  1516 #include <boost/bind/bind_mf_cc.hpp>

  1518 #undef BOOST_BIND_MF_NAME

  1519 #undef BOOST_BIND_MF_CC

  1521 #endif

  1523 #ifdef BOOST_MEM_FN_ENABLE_STDCALL

  1525 #define BOOST_BIND_MF_NAME(X) X##_stdcall

  1526 #define BOOST_BIND_MF_CC __stdcall

  1528 #include <boost/bind/bind_mf_cc.hpp>

  1530 #undef BOOST_BIND_MF_NAME

  1531 #undef BOOST_BIND_MF_CC

  1533 #endif

  1535 #ifdef BOOST_MEM_FN_ENABLE_FASTCALL

  1537 #define BOOST_BIND_MF_NAME(X) X##_fastcall

  1538 #define BOOST_BIND_MF_CC __fastcall

  1540 #include <boost/bind/bind_mf_cc.hpp>

  1542 #undef BOOST_BIND_MF_NAME

  1543 #undef BOOST_BIND_MF_CC

  1545 #endif

  1547 // data member pointers

  1549 #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \

  1550     || ( defined(__BORLANDC__) && BOOST_WORKAROUND( __BORLANDC__, < 0x600 ) )

  1552 template<class R, class T, class A1>

  1553 _bi::bind_t< R, _mfi::dm<R, T>, typename _bi::list_av_1<A1>::type >

  1554     BOOST_BIND(R T::*f, A1 a1)

  1555 {

  1556     typedef _mfi::dm<R, T> F;

  1557     typedef typename _bi::list_av_1<A1>::type list_type;

  1558     return _bi::bind_t<R, F, list_type>( F(f), list_type(a1) );

  1559 }

  1561 #else

  1563 namespace _bi

  1564 {

  1566 template< class Pm, int I > struct add_cref;

  1568 template< class M, class T > struct add_cref< M T::*, 0 >

  1569 {

  1570     typedef M type;

  1571 };

  1573 template< class M, class T > struct add_cref< M T::*, 1 >

  1574 {

  1575     typedef M const & type;

  1576 };

  1578 template< class R, class T > struct add_cref< R (T::*) (), 1 >

  1579 {

  1580     typedef void type;

  1581 };

  1583 #if !( defined(__IBMCPP__) && BOOST_WORKAROUND( __IBMCPP__, BOOST_TESTED_AT(600) ) )

  1585 template< class R, class T > struct add_cref< R (T::*) () const, 1 >

  1586 {

  1587     typedef void type;

  1588 };

  1590 #endif // __IBMCPP__

  1592 template<class R> struct isref

  1593 {

  1594     enum value_type { value = 0 };

  1595 };

  1597 template<class R> struct isref< R& >

  1598 {

  1599     enum value_type { value = 1 };

  1600 };

  1602 template<class R> struct isref< R* >

  1603 {

  1604     enum value_type { value = 1 };

  1605 };

  1607 template<class Pm, class A1> struct dm_result

  1608 {

  1609     typedef typename add_cref< Pm, 1 >::type type;

  1610 };

  1612 template<class Pm, class R, class F, class L> struct dm_result< Pm, bind_t<R, F, L> >

  1613 {

  1614     typedef typename bind_t<R, F, L>::result_type result_type;

  1615     typedef typename add_cref< Pm, isref< result_type >::value >::type type;

  1616 };

  1618 } // namespace _bi

  1620 template< class A1, class M, class T >

  1622 _bi::bind_t<

  1623     typename _bi::dm_result< M T::*, A1 >::type,

  1624     _mfi::dm<M, T>,

  1625     typename _bi::list_av_1<A1>::type

  1626 >

  1628 BOOST_BIND( M T::*f, A1 a1 )

  1629 {

  1630     typedef typename _bi::dm_result< M T::*, A1 >::type result_type;

  1631     typedef _mfi::dm<M, T> F;

  1632     typedef typename _bi::list_av_1<A1>::type list_type;

  1633     return _bi::bind_t< result_type, F, list_type >( F( f ), list_type( a1 ) );

  1634 }

  1636 #endif

  1638 } // namespace boost

  1640 #ifndef BOOST_BIND_NO_PLACEHOLDERS

  1642 # include <boost/bind/placeholders.hpp>

  1644 #endif

  1646 #ifdef BOOST_MSVC

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

  1648 # pragma warning(pop)

  1649 #endif

  1651 #endif // #ifndef BOOST_BIND_HPP_INCLUDED

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--