1 #ifndef BOOST_BIND_BIND_HPP_INCLUDED

     2 #define BOOST_BIND_BIND_HPP_INCLUDED

     3 

     4 // MS compatible compilers support #pragma once

     5 

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

     7 # pragma once

     8 #endif

     9 

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

    23 

    24 #include <boost/config.hpp>

    25 #include <boost/ref.hpp>

    26 #include <boost/mem_fn.hpp>

    27 #include <boost/type.hpp>

    28 #include <boost/is_placeholder.hpp>

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

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

    31 #include <boost/visit_each.hpp>

    32 

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

    34 

    35 #if defined(__BORLANDC__)

    36 #  define BOOST_BIND_VISIT_EACH boost::visit_each

    37 #else

    38 #  define BOOST_BIND_VISIT_EACH visit_each

    39 #endif

    40 

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

    42 

    43 #ifdef BOOST_MSVC

    44 # pragma warning(push)

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

    46 #endif

    47 

    48 namespace boost

    49 {

    50 

    51 template<class T> class weak_ptr;

    52 

    53 namespace _bi // implementation details

    54 {

    55 

    56 // result_traits

    57 

    58 template<class R, class F> struct result_traits

    59 {

    60     typedef R type;

    61 };

    62 

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

    64 

    65 struct unspecified {};

    66 

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

    68 {

    69     typedef typename F::result_type type;

    70 };

    71 

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

    73 {

    74     typedef typename F::result_type type;

    75 };

    76 

    77 #endif

    78 

    79 // ref_compare

    80 

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

    82 {

    83     return a == b;

    84 }

    85 

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

    87 {

    88     return true;

    89 }

    90 

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

    92 {

    93     return true;

    94 }

    95 

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

    97 {

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

    99 }

   100 

   101 // bind_t forward declaration for listN

   102 

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

   104 

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

   106 {

   107     return a.compare( b );

   108 }

   109 

   110 // value

   111 

   112 template<class T> class value

   113 {

   114 public:

   115 

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

   117 

   118     T & get() { return t_; }

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

   120 

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

   122     {

   123         return t_ == rhs.t_;

   124     }

   125 

   126 private:

   127 

   128     T t_;

   129 };

   130 

   131 // ref_compare for weak_ptr

   132 

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

   134 {

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

   136 }

   137 

   138 // type

   139 

   140 template<class T> class type {};

   141 

   142 // unwrap

   143 

   144 template<class F> struct unwrapper

   145 {

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

   147     {

   148         return f;

   149     }

   150 

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

   152     {

   153         return rf.get();

   154     }

   155 

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

   157     {

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

   159     }

   160 };

   161 

   162 // listN

   163 

   164 class list0

   165 {

   166 public:

   167 

   168     list0() {}

   169 

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

   171 

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

   173 

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

   175 

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

   177 

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

   179 

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

   181     {

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

   183     }

   184 

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

   186     {

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

   188     }

   189 

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

   191     {

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

   193     }

   194 

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

   196     {

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

   198     }

   199 

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

   201     {

   202     }

   203 

   204     bool operator==(list0 const &) const

   205     {

   206         return true;

   207     }

   208 };

   209 

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

   211 {

   212 private:

   213 

   214     typedef storage1< A1 > base_type;

   215 

   216 public:

   217 

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

   219 

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

   221 

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

   223 

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

   225 

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

   227 

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

   229 

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

   231 

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

   233 

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

   235     {

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

   237     }

   238 

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

   240     {

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

   242     }

   243 

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

   245     {

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

   247     }

   248 

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

   250     {

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

   252     }

   253 

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

   255     {

   256         base_type::accept(v);

   257     }

   258 

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

   260     {

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

   262     }

   263 };

   264 

   265 struct logical_and;

   266 struct logical_or;

   267 

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

   269 {

   270 private:

   271 

   272     typedef storage2< A1, A2 > base_type;

   273 

   274 public:

   275 

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

   277 

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

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

   280 

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

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

   283 

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

   285 

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

   287 

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

   289 

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

   291 

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

   293 

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

   295     {

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

   297     }

   298 

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

   300     {

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

   302     }

   303 

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

   305     {

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

   307     }

   308 

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

   310     {

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

   312     }

   313 

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

   315     {

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

   317     }

   318 

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

   320     {

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

   322     }

   323 

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

   325     {

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

   327     }

   328 

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

   330     {

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

   332     }

   333 

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

   335     {

   336         base_type::accept(v);

   337     }

   338 

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

   340     {

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

   342     }

   343 };

   344 

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

   346 {

   347 private:

   348 

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

   350 

   351 public:

   352 

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

   354 

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

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

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

   358 

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

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

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

   362 

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

   364 

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

   366 

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

   368 

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

   370 

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

   372 

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

   374     {

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

   376     }

   377 

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

   379     {

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

   381     }

   382 

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

   384     {

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

   386     }

   387 

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

   389     {

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

   391     }

   392 

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

   394     {

   395         base_type::accept(v);

   396     }

   397 

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

   399     {

   400         return

   401             

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

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

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

   405     }

   406 };

   407 

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

   409 {

   410 private:

   411 

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

   413 

   414 public:

   415 

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

   417 

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

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

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

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

   422 

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

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

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

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

   427 

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

   429 

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

   431 

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

   433 

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

   435 

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

   437 

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

   439     {

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

   441     }

   442 

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

   444     {

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

   446     }

   447 

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

   449     {

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

   451     }

   452 

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

   454     {

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

   456     }

   457 

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

   459     {

   460         base_type::accept(v);

   461     }

   462 

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

   464     {

   465         return

   466 

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

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

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

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

   471     }

   472 };

   473 

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

   475 {

   476 private:

   477 

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

   479 

   480 public:

   481 

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

   483 

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

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

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

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

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

   489 

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

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

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

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

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

   495 

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

   497 

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

   499 

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

   501 

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

   503 

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

   505 

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

   507     {

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

   509     }

   510 

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

   512     {

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

   514     }

   515 

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

   517     {

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

   519     }

   520 

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

   522     {

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

   524     }

   525 

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

   527     {

   528         base_type::accept(v);

   529     }

   530 

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

   532     {

   533         return

   534 

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

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

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

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

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

   540     }

   541 };

   542 

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

   544 {

   545 private:

   546 

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

   548 

   549 public:

   550 

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

   552 

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

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

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

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

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

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

   559 

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

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

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

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

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

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

   566 

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

   568 

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

   570 

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

   572 

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

   574 

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

   576 

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

   578     {

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

   580     }

   581 

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

   583     {

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

   585     }

   586 

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

   588     {

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

   590     }

   591 

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

   593     {

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

   595     }

   596 

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

   598     {

   599         base_type::accept(v);

   600     }

   601 

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

   603     {

   604         return

   605 

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

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

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

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

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

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

   612     }

   613 };

   614 

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

   616 {

   617 private:

   618 

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

   620 

   621 public:

   622 

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

   624 

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

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

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

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

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

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

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

   632 

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

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

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

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

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

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

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

   640 

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

   642 

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

   644 

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

   646 

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

   648 

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

   650 

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

   652     {

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

   654     }

   655 

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

   657     {

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

   659     }

   660 

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

   662     {

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

   664     }

   665 

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

   667     {

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

   669     }

   670 

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

   672     {

   673         base_type::accept(v);

   674     }

   675 

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

   677     {

   678         return

   679 

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

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

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

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

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

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

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

   687     }

   688 };

   689 

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

   691 {

   692 private:

   693 

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

   695 

   696 public:

   697 

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

   699 

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

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

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

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

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

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

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

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

   708 

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

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

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

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

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

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

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

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

   717 

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

   719 

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

   721 

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

   723 

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

   725 

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

   727 

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

   729     {

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

   731     }

   732 

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

   734     {

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

   736     }

   737 

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

   739     {

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

   741     }

   742 

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

   744     {

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

   746     }

   747 

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

   749     {

   750         base_type::accept(v);

   751     }

   752 

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

   754     {

   755         return

   756             

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

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

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

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

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

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

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

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

   765     }

   766 };

   767 

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

   769 {

   770 private:

   771 

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

   773 

   774 public:

   775 

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

   777 

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

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

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

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

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

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

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

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

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

   787 

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

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

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

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

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

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

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

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

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

   797 

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

   799 

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

   801 

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

   803 

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

   805 

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

   807 

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

   809     {

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

   811     }

   812 

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

   814     {

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

   816     }

   817 

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

   819     {

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

   821     }

   822 

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

   824     {

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

   826     }

   827 

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

   829     {

   830         base_type::accept(v);

   831     }

   832 

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

   834     {

   835         return

   836 

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

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

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

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

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

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

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

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

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

   846     }

   847 };

   848 

   849 // bind_t

   850 

   851 #ifndef BOOST_NO_VOID_RETURNS

   852 

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

   854 {

   855 public:

   856 

   857     typedef bind_t this_type;

   858 

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

   860 

   861 #define BOOST_BIND_RETURN return

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

   863 #undef BOOST_BIND_RETURN

   864 

   865 };

   866 

   867 #else

   868 

   869 template<class R> struct bind_t_generator

   870 {

   871 

   872 template<class F, class L> class implementation

   873 {

   874 public:

   875 

   876     typedef implementation this_type;

   877 

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

   879 

   880 #define BOOST_BIND_RETURN return

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

   882 #undef BOOST_BIND_RETURN

   883 

   884 };

   885 

   886 };

   887 

   888 template<> struct bind_t_generator<void>

   889 {

   890 

   891 template<class F, class L> class implementation

   892 {

   893 private:

   894 

   895     typedef void R;

   896 

   897 public:

   898 

   899     typedef implementation this_type;

   900 

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

   902 

   903 #define BOOST_BIND_RETURN

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

   905 #undef BOOST_BIND_RETURN

   906 

   907 };

   908 

   909 };

   910 

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

   912 {

   913 public:

   914 

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

   916 

   917 };

   918 

   919 #endif

   920 

   921 // function_equal

   922 

   923 #ifndef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP

   924 

   925 // put overloads in _bi, rely on ADL

   926 

   927 # ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING

   928 

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

   930 {

   931     return a.compare(b);

   932 }

   933 

   934 # else

   935 

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

   937 {

   938     return a.compare(b);

   939 }

   940 

   941 # endif // #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING

   942 

   943 #else // BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP

   944 

   945 // put overloads in boost

   946 

   947 } // namespace _bi

   948 

   949 # ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING

   950 

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

   952 {

   953     return a.compare(b);

   954 }

   955 

   956 # else

   957 

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

   959 {

   960     return a.compare(b);

   961 }

   962 

   963 # endif // #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING

   964 

   965 namespace _bi

   966 {

   967 

   968 #endif // BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP

   969 

   970 // add_value

   971 

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

   973 

   974 #if defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x582) )

   975 

   976 template<class T> struct add_value

   977 {

   978     typedef _bi::value<T> type;

   979 };

   980 

   981 #else

   982 

   983 template< class T, int I > struct add_value_2

   984 {

   985     typedef boost::arg<I> type;

   986 };

   987 

   988 template< class T > struct add_value_2< T, 0 >

   989 {

   990     typedef _bi::value< T > type;

   991 };

   992 

   993 template<class T> struct add_value

   994 {

   995     typedef typename add_value_2< T, boost::is_placeholder< T >::value >::type type;

   996 };

   997 

   998 #endif

   999 

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

  1001 {

  1002     typedef _bi::value<T> type;

  1003 };

  1004 

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

  1006 {

  1007     typedef reference_wrapper<T> type;

  1008 };

  1009 

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

  1011 {

  1012     typedef boost::arg<I> type;

  1013 };

  1014 

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

  1016 {

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

  1018 };

  1019 

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

  1021 {

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

  1023 };

  1024 

  1025 #else

  1026 

  1027 template<int I> struct _avt_0;

  1028 

  1029 template<> struct _avt_0<1>

  1030 {

  1031     template<class T> struct inner

  1032     {

  1033         typedef T type;

  1034     };

  1035 };

  1036 

  1037 template<> struct _avt_0<2>

  1038 {

  1039     template<class T> struct inner

  1040     {

  1041         typedef value<T> type;

  1042     };

  1043 };

  1044 

  1045 typedef char (&_avt_r1) [1];

  1046 typedef char (&_avt_r2) [2];

  1047 

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

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

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

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

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

  1053 

  1054 _avt_r2 _avt_f(...);

  1055 

  1056 template<class T> struct add_value

  1057 {

  1058     static T t();

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

  1060 };

  1061 

  1062 #endif

  1063 

  1064 // list_av_N

  1065 

  1066 template<class A1> struct list_av_1

  1067 {

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

  1069     typedef list1<B1> type;

  1070 };

  1071 

  1072 template<class A1, class A2> struct list_av_2

  1073 {

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

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

  1076     typedef list2<B1, B2> type;

  1077 };

  1078 

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

  1080 {

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

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

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

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

  1085 };

  1086 

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

  1088 {

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

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

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

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

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

  1094 };

  1095 

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

  1097 {

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

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

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

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

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

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

  1104 };

  1105 

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

  1107 {

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

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

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

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

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

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

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

  1115 };

  1116 

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

  1118 {

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

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

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

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

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

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

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

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

  1127 };

  1128 

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

  1130 {

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

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

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

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

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