boost/boost/bind.hpp

   1 #ifndef BOOST_BIND_HPP_INCLUDED
   2 #define BOOST_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 namespace _bi // implementation details
  52 {
  53
  54 // result_traits
  55
  56 template<class R, class F> struct result_traits
  57 {
  58     typedef R type;
  59 };
  60
  61 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
  62
  63 struct unspecified {};
  64
  65 template<class F> struct result_traits<unspecified, F>
  66 {
  67     typedef typename F::result_type type;
  68 };
  69
  70 template<class F> struct result_traits< unspecified, reference_wrapper<F> >
  71 {
  72     typedef typename F::result_type type;
  73 };
  74
  75 #endif
  76
  77 // ref_compare
  78
  79 template<class T> bool ref_compare( T const & a, T const & b, long )
  80 {
  81     return a == b;
  82 }
  83
  84 template<int I> bool ref_compare( arg<I> const &, arg<I> const &, int )
  85 {
  86     return true;
  87 }
  88
  89 template<int I> bool ref_compare( arg<I> (*) (), arg<I> (*) (), int )
  90 {
  91     return true;
  92 }
  93
  94 template<class T> bool ref_compare( reference_wrapper<T> const & a, reference_wrapper<T> const & b, int )
  95 {
  96     return a.get_pointer() == b.get_pointer();
  97 }
  98
  99 // bind_t forward declaration for listN
 100
 101 template<class R, class F, class L> class bind_t;
 102
 103 // value
 104
 105 template<class T> class value
 106 {
 107 public:
 108
 109     value(T const & t): t_(t) {}
 110
 111     T & get() { return t_; }
 112     T const & get() const { return t_; }
 113
 114     bool operator==(value const & rhs) const
 115     {
 116         return t_ == rhs.t_;
 117     }
 118
 119 private:
 120
 121     T t_;
 122 };
 123
 124 // type
 125
 126 template<class T> class type {};
 127
 128 // unwrap
 129
 130 template<class F> struct unwrapper
 131 {
 132     static inline F & unwrap( F & f, long )
 133     {
 134         return f;
 135     }
 136
 137     template<class F2> static inline F2 & unwrap( reference_wrapper<F2> rf, int )
 138     {
 139         return rf.get();
 140     }
 141
 142     template<class R, class T> static inline _mfi::dm<R, T> unwrap( R T::* pm, int )
 143     {
 144         return _mfi::dm<R, T>( pm );
 145     }
 146 };
 147
 148 // listN
 149
 150 class list0
 151 {
 152 public:
 153
 154     list0() {}
 155
 156     template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
 157
 158     template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
 159
 160     template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
 161
 162     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
 164     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
 166     template<class R, class F, class A> R operator()(type<R>, F & f, A &, long)
 167     {
 168         return unwrapper<F>::unwrap(f, 0)();
 169     }
 170
 171     template<class R, class F, class A> R operator()(type<R>, F const & f, A &, long) const
 172     {
 173         return unwrapper<F const>::unwrap(f, 0)();
 174     }
 175
 176     template<class F, class A> void operator()(type<void>, F & f, A &, int)
 177     {
 178         unwrapper<F>::unwrap(f, 0)();
 179     }
 180
 181     template<class F, class A> void operator()(type<void>, F const & f, A &, int) const
 182     {
 183         unwrapper<F const>::unwrap(f, 0)();
 184     }
 185
 186     template<class V> void accept(V &) const
 187     {
 188     }
 189
 190     bool operator==(list0 const &) const
 191     {
 192         return true;
 193     }
 194 };
 195
 196 template< class A1 > class list1: private storage1< A1 >
 197 {
 198 private:
 199
 200     typedef storage1< A1 > base_type;
 201
 202 public:
 203
 204     explicit list1( A1 a1 ): base_type( a1 ) {}
 205
 206     A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
 207
 208     A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
 209
 210     template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
 211
 212     template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
 213
 214     template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
 215
 216     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
 218     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
 220     template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
 221     {
 222         return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_]);
 223     }
 224
 225     template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
 226     {
 227         return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_]);
 228     }
 229
 230     template<class F, class A> void operator()(type<void>, F & f, A & a, int)
 231     {
 232         unwrapper<F>::unwrap(f, 0)(a[base_type::a1_]);
 233     }
 234
 235     template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
 236     {
 237         unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_]);
 238     }
 239
 240     template<class V> void accept(V & v) const
 241     {
 242         base_type::accept(v);
 243     }
 244
 245     bool operator==(list1 const & rhs) const
 246     {
 247         return ref_compare(base_type::a1_, rhs.a1_, 0);
 248     }
 249 };
 250
 251 struct logical_and;
 252 struct logical_or;
 253
 254 template< class A1, class A2 > class list2: private storage2< A1, A2 >
 255 {
 256 private:
 257
 258     typedef storage2< A1, A2 > base_type;
 259
 260 public:
 261
 262     list2( A1 a1, A2 a2 ): base_type( a1, a2 ) {}
 263
 264     A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
 265     A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
 266
 267     A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
 268     A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
 269
 270     template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
 271
 272     template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
 273
 274     template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
 275
 276     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); }
 277
 278     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); }
 279
 280     template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
 281     {
 282         return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
 283     }
 284
 285     template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
 286     {
 287         return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
 288     }
 289
 290     template<class F, class A> void operator()(type<void>, F & f, A & a, int)
 291     {
 292         unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
 293     }
 294
 295     template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
 296     {
 297         unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
 298     }
 299
 300     template<class A> bool operator()( type<bool>, logical_and & /*f*/, A & a, int )
 301     {
 302         return a[ base_type::a1_ ] && a[ base_type::a2_ ];
 303     }
 304
 305     template<class A> bool operator()( type<bool>, logical_and const & /*f*/, A & a, int ) const
 306     {
 307         return a[ base_type::a1_ ] && a[ base_type::a2_ ];
 308     }
 309
 310     template<class A> bool operator()( type<bool>, logical_or & /*f*/, A & a, int )
 311     {
 312         return a[ base_type::a1_ ] || a[ base_type::a2_ ];
 313     }
 314
 315     template<class A> bool operator()( type<bool>, logical_or const & /*f*/, A & a, int ) const
 316     {
 317         return a[ base_type::a1_ ] || a[ base_type::a2_ ];
 318     }
 319
 320     template<class V> void accept(V & v) const
 321     {
 322         base_type::accept(v);
 323     }
 324
 325     bool operator==(list2 const & rhs) const
 326     {
 327         return ref_compare(base_type::a1_, rhs.a1_, 0) && ref_compare(base_type::a2_, rhs.a2_, 0);
 328     }
 329 };
 330
 331 template< class A1, class A2, class A3 > class list3: private storage3< A1, A2, A3 >
 332 {
 333 private:
 334
 335     typedef storage3< A1, A2, A3 > base_type;
 336
 337 public:
 338
 339     list3( A1 a1, A2 a2, A3 a3 ): base_type( a1, a2, a3 ) {}
 340
 341     A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
 342     A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
 343     A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
 344
 345     A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
 346     A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
 347     A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
 348
 349     template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
 350
 351     template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
 352
 353     template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
 354
 355     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); }
 356
 357     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); }
 358
 359     template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
 360     {
 361         return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
 362     }
 363
 364     template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
 365     {
 366         return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
 367     }
 368
 369     template<class F, class A> void operator()(type<void>, F & f, A & a, int)
 370     {
 371         unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
 372     }
 373
 374     template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
 375     {
 376         unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
 377     }
 378
 379     template<class V> void accept(V & v) const
 380     {
 381         base_type::accept(v);
 382     }
 383
 384     bool operator==(list3 const & rhs) const
 385     {
 386         return
 387
 388             ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
 389             ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
 390             ref_compare( base_type::a3_, rhs.a3_, 0 );
 391     }
 392 };
 393
 394 template< class A1, class A2, class A3, class A4 > class list4: private storage4< A1, A2, A3, A4 >
 395 {
 396 private:
 397
 398     typedef storage4< A1, A2, A3, A4 > base_type;
 399
 400 public:
 401
 402     list4( A1 a1, A2 a2, A3 a3, A4 a4 ): base_type( a1, a2, a3, a4 ) {}
 403
 404     A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
 405     A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
 406     A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
 407     A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
 408
 409     A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
 410     A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
 411     A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
 412     A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
 413
 414     template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
 415
 416     template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
 417
 418     template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
 419
 420     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); }
 421
 422     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); }
 423
 424     template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
 425     {
 426         return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
 427     }
 428
 429     template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
 430     {
 431         return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
 432     }
 433
 434     template<class F, class A> void operator()(type<void>, F & f, A & a, int)
 435     {
 436         unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
 437     }
 438
 439     template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
 440     {
 441         unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
 442     }
 443
 444     template<class V> void accept(V & v) const
 445     {
 446         base_type::accept(v);
 447     }
 448
 449     bool operator==(list4 const & rhs) const
 450     {
 451         return
 452
 453             ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
 454             ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
 455             ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
 456             ref_compare( base_type::a4_, rhs.a4_, 0 );
 457     }
 458 };
 459
 460 template< class A1, class A2, class A3, class A4, class A5 > class list5: private storage5< A1, A2, A3, A4, A5 >
 461 {
 462 private:
 463
 464     typedef storage5< A1, A2, A3, A4, A5 > base_type;
 465
 466 public:
 467
 468     list5( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5 ): base_type( a1, a2, a3, a4, a5 ) {}
 469
 470     A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
 471     A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
 472     A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
 473     A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
 474     A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
 475
 476     A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
 477     A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
 478     A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
 479     A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
 480     A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
 481
 482     template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
 483
 484     template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
 485
 486     template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
 487
 488     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); }
 489
 490     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); }
 491
 492     template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
 493     {
 494         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_]);
 495     }
 496
 497     template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
 498     {
 499         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_]);
 500     }
 501
 502     template<class F, class A> void operator()(type<void>, F & f, A & a, int)
 503     {
 504         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_]);
 505     }
 506
 507     template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
 508     {
 509         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_]);
 510     }
 511
 512     template<class V> void accept(V & v) const
 513     {
 514         base_type::accept(v);
 515     }
 516
 517     bool operator==(list5 const & rhs) const
 518     {
 519         return
 520
 521             ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
 522             ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
 523             ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
 524             ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
 525             ref_compare( base_type::a5_, rhs.a5_, 0 );
 526     }
 527 };
 528
 529 template<class A1, class A2, class A3, class A4, class A5, class A6> class list6: private storage6< A1, A2, A3, A4, A5, A6 >
 530 {
 531 private:
 532
 533     typedef storage6< A1, A2, A3, A4, A5, A6 > base_type;
 534
 535 public:
 536
 537     list6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6 ): base_type( a1, a2, a3, a4, a5, a6 ) {}
 538
 539     A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
 540     A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
 541     A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
 542     A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
 543     A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
 544     A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
 545
 546     A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
 547     A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
 548     A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
 549     A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
 550     A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
 551     A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
 552
 553     template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
 554
 555     template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
 556
 557     template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
 558
 559     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); }
 560
 561     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); }
 562
 563     template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
 564     {
 565         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_]);
 566     }
 567
 568     template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
 569     {
 570         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_]);
 571     }
 572
 573     template<class F, class A> void operator()(type<void>, F & f, A & a, int)
 574     {
 575         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_]);
 576     }
 577
 578     template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
 579     {
 580         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_]);
 581     }
 582
 583     template<class V> void accept(V & v) const
 584     {
 585         base_type::accept(v);
 586     }
 587
 588     bool operator==(list6 const & rhs) const
 589     {
 590         return
 591
 592             ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
 593             ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
 594             ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
 595             ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
 596             ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
 597             ref_compare( base_type::a6_, rhs.a6_, 0 );
 598     }
 599 };
 600
 601 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 >
 602 {
 603 private:
 604
 605     typedef storage7< A1, A2, A3, A4, A5, A6, A7 > base_type;
 606
 607 public:
 608
 609     list7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7 ): base_type( a1, a2, a3, a4, a5, a6, a7 ) {}
 610
 611     A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
 612     A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
 613     A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
 614     A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
 615     A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
 616     A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
 617     A7 operator[] (boost::arg<7>) const { return base_type::a7_; }
 618
 619     A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
 620     A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
 621     A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
 622     A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
 623     A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
 624     A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
 625     A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; }
 626
 627     template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
 628
 629     template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
 630
 631     template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
 632
 633     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); }
 634
 635     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); }
 636
 637     template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
 638     {
 639         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_]);
 640     }
 641
 642     template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
 643     {
 644         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_]);
 645     }
 646
 647     template<class F, class A> void operator()(type<void>, F & f, A & a, int)
 648     {
 649         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_]);
 650     }
 651
 652     template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
 653     {
 654         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_]);
 655     }
 656
 657     template<class V> void accept(V & v) const
 658     {
 659         base_type::accept(v);
 660     }
 661
 662     bool operator==(list7 const & rhs) const
 663     {
 664         return
 665
 666             ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
 667             ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
 668             ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
 669             ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
 670             ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
 671             ref_compare( base_type::a6_, rhs.a6_, 0 ) &&
 672             ref_compare( base_type::a7_, rhs.a7_, 0 );
 673     }
 674 };
 675
 676 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 >
 677 {
 678 private:
 679
 680     typedef storage8< A1, A2, A3, A4, A5, A6, A7, A8 > base_type;
 681
 682 public:
 683
 684     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 ) {}
 685
 686     A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
 687     A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
 688     A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
 689     A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
 690     A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
 691     A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
 692     A7 operator[] (boost::arg<7>) const { return base_type::a7_; }
 693     A8 operator[] (boost::arg<8>) const { return base_type::a8_; }
 694
 695     A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
 696     A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
 697     A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
 698     A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
 699     A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
 700     A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
 701     A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; }
 702     A8 operator[] (boost::arg<8> (*) ()) const { return base_type::a8_; }
 703
 704     template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
 705
 706     template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
 707
 708     template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
 709
 710     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); }
 711
 712     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); }
 713
 714     template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
 715     {
 716         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_]);
 717     }
 718
 719     template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
 720     {
 721         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_]);
 722     }
 723
 724     template<class F, class A> void operator()(type<void>, F & f, A & a, int)
 725     {
 726         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_]);
 727     }
 728
 729     template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
 730     {
 731         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_]);
 732     }
 733
 734     template<class V> void accept(V & v) const
 735     {
 736         base_type::accept(v);
 737     }
 738
 739     bool operator==(list8 const & rhs) const
 740     {
 741         return
 742
 743             ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
 744             ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
 745             ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
 746             ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
 747             ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
 748             ref_compare( base_type::a6_, rhs.a6_, 0 ) &&
 749             ref_compare( base_type::a7_, rhs.a7_, 0 ) &&
 750             ref_compare( base_type::a8_, rhs.a8_, 0 );
 751     }
 752 };
 753
 754 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 >
 755 {
 756 private:
 757
 758     typedef storage9< A1, A2, A3, A4, A5, A6, A7, A8, A9 > base_type;
 759
 760 public:
 761
 762     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 ) {}
 763
 764     A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
 765     A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
 766     A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
 767     A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
 768     A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
 769     A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
 770     A7 operator[] (boost::arg<7>) const { return base_type::a7_; }
 771     A8 operator[] (boost::arg<8>) const { return base_type::a8_; }
 772     A9 operator[] (boost::arg<9>) const { return base_type::a9_; }
 773
 774     A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
 775     A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
 776     A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
 777     A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
 778     A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
 779     A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
 780     A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; }
 781     A8 operator[] (boost::arg<8> (*) ()) const { return base_type::a8_; }
 782     A9 operator[] (boost::arg<9> (*) ()) const { return base_type::a9_; }
 783
 784     template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
 785
 786     template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
 787
 788     template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
 789
 790     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); }
 791
 792     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); }
 793
 794     template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
 795     {
 796         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_]);
 797     }
 798
 799     template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
 800     {
 801         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_]);
 802     }
 803
 804     template<class F, class A> void operator()(type<void>, F & f, A & a, int)
 805     {
 806         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_]);
 807     }
 808
 809     template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
 810     {
 811         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_]);
 812     }
 813
 814     template<class V> void accept(V & v) const
 815     {
 816         base_type::accept(v);
 817     }
 818
 819     bool operator==(list9 const & rhs) const
 820     {
 821         return
 822
 823             ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
 824             ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
 825             ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
 826             ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
 827             ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
 828             ref_compare( base_type::a6_, rhs.a6_, 0 ) &&
 829             ref_compare( base_type::a7_, rhs.a7_, 0 ) &&
 830             ref_compare( base_type::a8_, rhs.a8_, 0 ) &&
 831             ref_compare( base_type::a9_, rhs.a9_, 0 );
 832     }
 833 };
 834
 835 // bind_t
 836
 837 #ifndef BOOST_NO_VOID_RETURNS
 838
 839 template<class R, class F, class L> class bind_t
 840 {
 841 public:
 842
 843     typedef bind_t this_type;
 844
 845     bind_t(F f, L const & l): f_(f), l_(l) {}
 846
 847 #define BOOST_BIND_RETURN return
 848 #include <boost/bind/bind_template.hpp>
 849 #undef BOOST_BIND_RETURN
 850
 851 };
 852
 853 #else
 854
 855 template<class R> struct bind_t_generator
 856 {
 857
 858 template<class F, class L> class implementation
 859 {
 860 public:
 861
 862     typedef implementation this_type;
 863
 864     implementation(F f, L const & l): f_(f), l_(l) {}
 865
 866 #define BOOST_BIND_RETURN return
 867 #include <boost/bind/bind_template.hpp>
 868 #undef BOOST_BIND_RETURN
 869
 870 };
 871
 872 };
 873
 874 template<> struct bind_t_generator<void>
 875 {
 876
 877 template<class F, class L> class implementation
 878 {
 879 private:
 880
 881     typedef void R;
 882
 883 public:
 884
 885     typedef implementation this_type;
 886
 887     implementation(F f, L const & l): f_(f), l_(l) {}
 888
 889 #define BOOST_BIND_RETURN
 890 #include <boost/bind/bind_template.hpp>
 891 #undef BOOST_BIND_RETURN
 892
 893 };
 894
 895 };
 896
 897 template<class R2, class F, class L> class bind_t: public bind_t_generator<R2>::BOOST_NESTED_TEMPLATE implementation<F, L>
 898 {
 899 public:
 900
 901     bind_t(F f, L const & l): bind_t_generator<R2>::BOOST_NESTED_TEMPLATE implementation<F, L>(f, l) {}
 902
 903 };
 904
 905 #endif
 906
 907 // function_equal
 908
 909 #ifndef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
 910
 911 // put overloads in _bi, rely on ADL
 912
 913 # ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
 914
 915 template<class R, class F, class L> bool function_equal( bind_t<R, F, L> const & a, bind_t<R, F, L> const & b )
 916 {
 917     return a.compare(b);
 918 }
 919
 920 # else
 921
 922 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 )
 923 {
 924     return a.compare(b);
 925 }
 926
 927 # endif // #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
 928
 929 #else // BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
 930
 931 // put overloads in boost
 932
 933 } // namespace _bi
 934
 935 # ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
 936
 937 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 )
 938 {
 939     return a.compare(b);
 940 }
 941
 942 # else
 943
 944 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 )
 945 {
 946     return a.compare(b);
 947 }
 948
 949 # endif // #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
 950
 951 namespace _bi
 952 {
 953
 954 #endif // BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
 955
 956 // add_value
 957
 958 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) || (__SUNPRO_CC >= 0x530)
 959
 960 #if defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x582) )
 961
 962 template<class T> struct add_value
 963 {
 964     typedef _bi::value<T> type;
 965 };
 966
 967 #else
 968
 969 template< class T, int I > struct add_value_2
 970 {
 971     typedef boost::arg<I> type;
 972 };
 973
 974 template< class T > struct add_value_2< T, 0 >
 975 {
 976     typedef _bi::value< T > type;
 977 };
 978
 979 template<class T> struct add_value
 980 {
 981     typedef typename add_value_2< T, boost::is_placeholder< T >::value >::type type;
 982 };
 983
 984 #endif
 985
 986 template<class T> struct add_value< value<T> >
 987 {
 988     typedef _bi::value<T> type;
 989 };
 990
 991 template<class T> struct add_value< reference_wrapper<T> >
 992 {
 993     typedef reference_wrapper<T> type;
 994 };
 995
 996 template<int I> struct add_value< arg<I> >
 997 {
 998     typedef boost::arg<I> type;
 999 };
1000
1001 template<int I> struct add_value< arg<I> (*) () >
1002 {
1003     typedef boost::arg<I> (*type) ();
1004 };
1005
1006 template<class R, class F, class L> struct add_value< bind_t<R, F, L> >
1007 {
1008     typedef bind_t<R, F, L> type;
1009 };
1010
1011 #else
1012
1013 template<int I> struct _avt_0;
1014
1015 template<> struct _avt_0<1>
1016 {
1017     template<class T> struct inner
1018     {
1019         typedef T type;
1020     };
1021 };
1022
1023 template<> struct _avt_0<2>
1024 {
1025     template<class T> struct inner
1026     {
1027         typedef value<T> type;
1028     };
1029 };
1030
1031 typedef char (&_avt_r1) [1];
1032 typedef char (&_avt_r2) [2];
1033
1034 template<class T> _avt_r1 _avt_f(value<T>);
1035 template<class T> _avt_r1 _avt_f(reference_wrapper<T>);
1036 template<int I> _avt_r1 _avt_f(arg<I>);
1037 template<int I> _avt_r1 _avt_f(arg<I> (*) ());
1038 template<class R, class F, class L> _avt_r1 _avt_f(bind_t<R, F, L>);
1039
1040 _avt_r2 _avt_f(...);
1041
1042 template<class T> struct add_value
1043 {
1044     static T t();
1045     typedef typename _avt_0<sizeof(_avt_f(t()))>::template inner<T>::type type;
1046 };
1047
1048 #endif
1049
1050 // list_av_N
1051
1052 template<class A1> struct list_av_1
1053 {
1054     typedef typename add_value<A1>::type B1;
1055     typedef list1<B1> type;
1056 };
1057
1058 template<class A1, class A2> struct list_av_2
1059 {
1060     typedef typename add_value<A1>::type B1;
1061     typedef typename add_value<A2>::type B2;
1062     typedef list2<B1, B2> type;
1063 };
1064
1065 template<class A1, class A2, class A3> struct list_av_3
1066 {
1067     typedef typename add_value<A1>::type B1;
1068     typedef typename add_value<A2>::type B2;
1069     typedef typename add_value<A3>::type B3;
1070     typedef list3<B1, B2, B3> type;
1071 };
1072
1073 template<class A1, class A2, class A3, class A4> struct list_av_4
1074 {
1075     typedef typename add_value<A1>::type B1;
1076     typedef typename add_value<A2>::type B2;
1077     typedef typename add_value<A3>::type B3;
1078     typedef typename add_value<A4>::type B4;
1079     typedef list4<B1, B2, B3, B4> type;
1080 };
1081
1082 template<class A1, class A2, class A3, class A4, class A5> struct list_av_5
1083 {
1084     typedef typename add_value<A1>::type B1;
1085     typedef typename add_value<A2>::type B2;
1086     typedef typename add_value<A3>::type B3;
1087     typedef typename add_value<A4>::type B4;
1088     typedef typename add_value<A5>::type B5;
1089     typedef list5<B1, B2, B3, B4, B5> type;
1090 };
1091
1092 template<class A1, class A2, class A3, class A4, class A5, class A6> struct list_av_6
1093 {
1094     typedef typename add_value<A1>::type B1;
1095     typedef typename add_value<A2>::type B2;
1096     typedef typename add_value<A3>::type B3;
1097     typedef typename add_value<A4>::type B4;
1098     typedef typename add_value<A5>::type B5;
1099     typedef typename add_value<A6>::type B6;
1100     typedef list6<B1, B2, B3, B4, B5, B6> type;
1101 };
1102
1103 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct list_av_7
1104 {
1105     typedef typename add_value<A1>::type B1;
1106     typedef typename add_value<A2>::type B2;
1107     typedef typename add_value<A3>::type B3;
1108     typedef typename add_value<A4>::type B4;
1109     typedef typename add_value<A5>::type B5;
1110     typedef typename add_value<A6>::type B6;
1111     typedef typename add_value<A7>::type B7;
1112     typedef list7<B1, B2, B3, B4, B5, B6, B7> type;
1113 };
1114
1115 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct list_av_8
1116 {
1117     typedef typename add_value<A1>::type B1;
1118     typedef typename add_value<A2>::type B2;
1119     typedef typename add_value<A3>::type B3;
1120     typedef typename add_value<A4>::type B4;
1121     typedef typename add_value<A5>::type B5;
1122     typedef typename add_value<A6>::type B6;
1123     typedef typename add_value<A7>::type B7;
1124     typedef typename add_value<A8>::type B8;
1125     typedef list8<B1, B2, B3, B4, B5, B6, B7, B8> type;
1126 };
1127
1128 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> struct list_av_9
1129 {
1130     typedef typename add_value<A1>::type B1;
1131     typedef typename add_value<A2>::type B2;
1132     typedef typename add_value<A3>::type B3;
1133     typedef typename add_value<A4>::type B4;
1134     typedef typename add_value<A5>::type B5;
1135     typedef typename add_value<A6>::type B6;
1136     typedef typename add_value<A7>::type B7;
1137     typedef typename add_value<A8>::type B8;
1138     typedef typename add_value<A9>::type B9;
1139     typedef list9<B1, B2, B3, B4, B5, B6, B7, B8, B9> type;
1140 };
1141
1142 // operator!
1143
1144 struct logical_not
1145 {
1146     template<class V> bool operator()(V const & v) const { return !v; }
1147 };
1148
1149 template<class R, class F, class L>
1150     bind_t< bool, logical_not, list1< bind_t<R, F, L> > >
1151     operator! (bind_t<R, F, L> const & f)
1152 {
1153     typedef list1< bind_t<R, F, L> > list_type;
1154     return bind_t<bool, logical_not, list_type> ( logical_not(), list_type(f) );
1155 }
1156
1157 // relational operators
1158
1159 #define BOOST_BIND_OPERATOR( op, name ) \
1160 \
1161 struct name \
1162 { \
1163     template<class V, class W> bool operator()(V const & v, W const & w) const { return v op w; } \
1164 }; \
1165  \
1166 template<class R, class F, class L, class A2> \
1167     bind_t< bool, name, list2< bind_t<R, F, L>, typename add_value<A2>::type > > \
1168     operator op (bind_t<R, F, L> const & f, A2 a2) \
1169 { \
1170     typedef typename add_value<A2>::type B2; \
1171     typedef list2< bind_t<R, F, L>, B2> list_type; \
1172     return bind_t<bool, name, list_type> ( name(), list_type(f, a2) ); \
1173 }
1174
1175 BOOST_BIND_OPERATOR( ==, equal )
1176 BOOST_BIND_OPERATOR( !=, not_equal )
1177
1178 BOOST_BIND_OPERATOR( <, less )
1179 BOOST_BIND_OPERATOR( <=, less_equal )
1180
1181 BOOST_BIND_OPERATOR( >, greater )
1182 BOOST_BIND_OPERATOR( >=, greater_equal )
1183
1184 BOOST_BIND_OPERATOR( &&, logical_and )
1185 BOOST_BIND_OPERATOR( ||, logical_or )
1186
1187 #undef BOOST_BIND_OPERATOR
1188
1189 #if defined(__GNUC__) && BOOST_WORKAROUND(__GNUC__, < 3)
1190
1191 // resolve ambiguity with rel_ops
1192
1193 #define BOOST_BIND_OPERATOR( op, name ) \
1194 \
1195 template<class R, class F, class L> \
1196     bind_t< bool, name, list2< bind_t<R, F, L>, bind_t<R, F, L> > > \
1197     operator op (bind_t<R, F, L> const & f, bind_t<R, F, L> const & g) \
1198 { \
1199     typedef list2< bind_t<R, F, L>, bind_t<R, F, L> > list_type; \
1200     return bind_t<bool, name, list_type> ( name(), list_type(f, g) ); \
1201 }
1202
1203 BOOST_BIND_OPERATOR( !=, not_equal )
1204 BOOST_BIND_OPERATOR( <=, less_equal )
1205 BOOST_BIND_OPERATOR( >, greater )
1206 BOOST_BIND_OPERATOR( >=, greater_equal )
1207
1208 #endif
1209
1210 // visit_each, ADL
1211
1212 #if !defined( BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP ) && !defined( __BORLANDC__ ) \
1213    && !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
1214
1215 template<class V, class T> void visit_each( V & v, value<T> const & t, int )
1216 {
1217     using boost::visit_each;
1218     BOOST_BIND_VISIT_EACH( v, t.get(), 0 );
1219 }
1220
1221 template<class V, class R, class F, class L> void visit_each( V & v, bind_t<R, F, L> const & t, int )
1222 {
1223     t.accept( v );
1224 }
1225
1226 #endif
1227
1228 } // namespace _bi
1229
1230 // visit_each, no ADL
1231
1232 #if defined( BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP ) || defined( __BORLANDC__ ) \
1233   || (defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
1234
1235 template<class V, class T> void visit_each( V & v, _bi::value<T> const & t, int )
1236 {
1237     BOOST_BIND_VISIT_EACH( v, t.get(), 0 );
1238 }
1239
1240 template<class V, class R, class F, class L> void visit_each( V & v, _bi::bind_t<R, F, L> const & t, int )
1241 {
1242     t.accept( v );
1243 }
1244
1245 #endif
1246
1247 // is_bind_expression
1248
1249 template< class T > struct is_bind_expression
1250 {
1251     enum _vt { value = 0 };
1252 };
1253
1254 #if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
1255
1256 template< class R, class F, class L > struct is_bind_expression< _bi::bind_t< R, F, L > >
1257 {
1258     enum _vt { value = 1 };
1259 };
1260
1261 #endif
1262
1263 // bind
1264
1265 #ifndef BOOST_BIND
1266 #define BOOST_BIND bind
1267 #endif
1268
1269 // generic function objects
1270
1271 template<class R, class F>
1272     _bi::bind_t<R, F, _bi::list0>
1273     BOOST_BIND(F f)
1274 {
1275     typedef _bi::list0 list_type;
1276     return _bi::bind_t<R, F, list_type> (f, list_type());
1277 }
1278
1279 template<class R, class F, class A1>
1280     _bi::bind_t<R, F, typename _bi::list_av_1<A1>::type>
1281     BOOST_BIND(F f, A1 a1)
1282 {
1283     typedef typename _bi::list_av_1<A1>::type list_type;
1284     return _bi::bind_t<R, F, list_type> (f, list_type(a1));
1285 }
1286
1287 template<class R, class F, class A1, class A2>
1288     _bi::bind_t<R, F, typename _bi::list_av_2<A1, A2>::type>
1289     BOOST_BIND(F f, A1 a1, A2 a2)
1290 {
1291     typedef typename _bi::list_av_2<A1, A2>::type list_type;
1292     return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
1293 }
1294
1295 template<class R, class F, class A1, class A2, class A3>
1296     _bi::bind_t<R, F, typename _bi::list_av_3<A1, A2, A3>::type>
1297     BOOST_BIND(F f, A1 a1, A2 a2, A3 a3)
1298 {
1299     typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
1300     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
1301 }
1302
1303 template<class R, class F, class A1, class A2, class A3, class A4>
1304     _bi::bind_t<R, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>
1305     BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4)
1306 {
1307     typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
1308     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
1309 }
1310
1311 template<class R, class F, class A1, class A2, class A3, class A4, class A5>
1312     _bi::bind_t<R, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
1313     BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
1314 {
1315     typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
1316     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
1317 }
1318
1319 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6>
1320     _bi::bind_t<R, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
1321     BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
1322 {
1323     typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
1324     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
1325 }
1326
1327 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
1328     _bi::bind_t<R, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
1329     BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
1330 {
1331     typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
1332     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
1333 }
1334
1335 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
1336     _bi::bind_t<R, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
1337     BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
1338 {
1339     typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
1340     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
1341 }
1342
1343 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
1344     _bi::bind_t<R, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
1345     BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
1346 {
1347     typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
1348     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
1349 }
1350
1351 // generic function objects, alternative syntax
1352
1353 template<class R, class F>
1354     _bi::bind_t<R, F, _bi::list0>
1355     BOOST_BIND(boost::type<R>, F f)
1356 {
1357     typedef _bi::list0 list_type;
1358     return _bi::bind_t<R, F, list_type> (f, list_type());
1359 }
1360
1361 template<class R, class F, class A1>
1362     _bi::bind_t<R, F, typename _bi::list_av_1<A1>::type>
1363     BOOST_BIND(boost::type<R>, F f, A1 a1)
1364 {
1365     typedef typename _bi::list_av_1<A1>::type list_type;
1366     return _bi::bind_t<R, F, list_type> (f, list_type(a1));
1367 }
1368
1369 template<class R, class F, class A1, class A2>
1370     _bi::bind_t<R, F, typename _bi::list_av_2<A1, A2>::type>
1371     BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2)
1372 {
1373     typedef typename _bi::list_av_2<A1, A2>::type list_type;
1374     return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
1375 }
1376
1377 template<class R, class F, class A1, class A2, class A3>
1378     _bi::bind_t<R, F, typename _bi::list_av_3<A1, A2, A3>::type>
1379     BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3)
1380 {
1381     typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
1382     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
1383 }
1384
1385 template<class R, class F, class A1, class A2, class A3, class A4>
1386     _bi::bind_t<R, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>
1387     BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4)
1388 {
1389     typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
1390     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
1391 }
1392
1393 template<class R, class F, class A1, class A2, class A3, class A4, class A5>
1394     _bi::bind_t<R, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
1395     BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
1396 {
1397     typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
1398     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
1399 }
1400
1401 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6>
1402     _bi::bind_t<R, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
1403     BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
1404 {
1405     typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
1406     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
1407 }
1408
1409 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
1410     _bi::bind_t<R, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
1411     BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
1412 {
1413     typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
1414     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
1415 }
1416
1417 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
1418     _bi::bind_t<R, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
1419     BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
1420 {
1421     typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
1422     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
1423 }
1424
1425 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
1426     _bi::bind_t<R, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
1427     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)
1428 {
1429     typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
1430     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
1431 }
1432
1433 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
1434
1435 // adaptable function objects
1436
1437 template<class F>
1438     _bi::bind_t<_bi::unspecified, F, _bi::list0>
1439     BOOST_BIND(F f)
1440 {
1441     typedef _bi::list0 list_type;
1442     return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type());
1443 }
1444
1445 template<class F, class A1>
1446     _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_1<A1>::type>
1447     BOOST_BIND(F f, A1 a1)
1448 {
1449     typedef typename _bi::list_av_1<A1>::type list_type;
1450     return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type(a1));
1451 }
1452
1453 template<class F, class A1, class A2>
1454     _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_2<A1, A2>::type>
1455     BOOST_BIND(F f, A1 a1, A2 a2)
1456 {
1457     typedef typename _bi::list_av_2<A1, A2>::type list_type;
1458     return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type(a1, a2));
1459 }
1460
1461 template<class F, class A1, class A2, class A3>
1462     _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_3<A1, A2, A3>::type>
1463     BOOST_BIND(F f, A1 a1, A2 a2, A3 a3)
1464 {
1465     typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
1466     return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3));
1467 }
1468
1469 template<class F, class A1, class A2, class A3, class A4>
1470     _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>
1471     BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4)
1472 {
1473     typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
1474     return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4));
1475 }
1476
1477 template<class F, class A1, class A2, class A3, class A4, class A5>
1478     _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
1479     BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
1480 {
1481     typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
1482     return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
1483 }
1484
1485 template<class F, class A1, class A2, class A3, class A4, class A5, class A6>
1486     _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
1487     BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
1488 {
1489     typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
1490     return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
1491 }
1492
1493 template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
1494     _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
1495     BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
1496 {
1497     typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
1498     return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
1499 }
1500
1501 template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
1502     _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
1503     BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
1504 {
1505     typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
1506     return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
1507 }
1508
1509 template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
1510     _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
1511     BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
1512 {
1513     typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
1514     return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
1515 }
1516
1517 #endif // !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
1518
1519 // function pointers
1520
1521 #define BOOST_BIND_CC
1522 #define BOOST_BIND_ST
1523
1524 #include <boost/bind/bind_cc.hpp>
1525
1526 #undef BOOST_BIND_CC
1527 #undef BOOST_BIND_ST
1528
1529 #ifdef BOOST_BIND_ENABLE_STDCALL
1530
1531 #define BOOST_BIND_CC __stdcall
1532 #define BOOST_BIND_ST
1533
1534 #include <boost/bind/bind_cc.hpp>
1535
1536 #undef BOOST_BIND_CC
1537 #undef BOOST_BIND_ST
1538
1539 #endif
1540
1541 #ifdef BOOST_BIND_ENABLE_FASTCALL
1542
1543 #define BOOST_BIND_CC __fastcall
1544 #define BOOST_BIND_ST
1545
1546 #include <boost/bind/bind_cc.hpp>
1547
1548 #undef BOOST_BIND_CC
1549 #undef BOOST_BIND_ST
1550
1551 #endif
1552
1553 #ifdef BOOST_BIND_ENABLE_PASCAL
1554
1555 #define BOOST_BIND_ST pascal
1556 #define BOOST_BIND_CC
1557
1558 #include <boost/bind/bind_cc.hpp>
1559
1560 #undef BOOST_BIND_ST
1561 #undef BOOST_BIND_CC
1562
1563 #endif
1564
1565 // member function pointers
1566
1567 #define BOOST_BIND_MF_NAME(X) X
1568 #define BOOST_BIND_MF_CC
1569
1570 #include <boost/bind/bind_mf_cc.hpp>
1571 #include <boost/bind/bind_mf2_cc.hpp>
1572
1573 #undef BOOST_BIND_MF_NAME
1574 #undef BOOST_BIND_MF_CC
1575
1576 #ifdef BOOST_MEM_FN_ENABLE_CDECL
1577
1578 #define BOOST_BIND_MF_NAME(X) X##_cdecl
1579 #define BOOST_BIND_MF_CC __cdecl
1580
1581 #include <boost/bind/bind_mf_cc.hpp>
1582 #include <boost/bind/bind_mf2_cc.hpp>
1583
1584 #undef BOOST_BIND_MF_NAME
1585 #undef BOOST_BIND_MF_CC
1586
1587 #endif
1588
1589 #ifdef BOOST_MEM_FN_ENABLE_STDCALL
1590
1591 #define BOOST_BIND_MF_NAME(X) X##_stdcall
1592 #define BOOST_BIND_MF_CC __stdcall
1593
1594 #include <boost/bind/bind_mf_cc.hpp>
1595 #include <boost/bind/bind_mf2_cc.hpp>
1596
1597 #undef BOOST_BIND_MF_NAME
1598 #undef BOOST_BIND_MF_CC
1599
1600 #endif
1601
1602 #ifdef BOOST_MEM_FN_ENABLE_FASTCALL
1603
1604 #define BOOST_BIND_MF_NAME(X) X##_fastcall
1605 #define BOOST_BIND_MF_CC __fastcall
1606
1607 #include <boost/bind/bind_mf_cc.hpp>
1608 #include <boost/bind/bind_mf2_cc.hpp>
1609
1610 #undef BOOST_BIND_MF_NAME
1611 #undef BOOST_BIND_MF_CC
1612
1613 #endif
1614
1615 // data member pointers
1616
1617 #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
1618     || ( defined(__BORLANDC__) && BOOST_WORKAROUND( __BORLANDC__, < 0x600 ) )
1619
1620 template<class R, class T, class A1>
1621 _bi::bind_t< R, _mfi::dm<R, T>, typename _bi::list_av_1<A1>::type >
1622     BOOST_BIND(R T::*f, A1 a1)
1623 {
1624     typedef _mfi::dm<R, T> F;
1625     typedef typename _bi::list_av_1<A1>::type list_type;
1626     return _bi::bind_t<R, F, list_type>( F(f), list_type(a1) );
1627 }
1628
1629 #else
1630
1631 namespace _bi
1632 {
1633
1634 template< class Pm, int I > struct add_cref;
1635
1636 template< class M, class T > struct add_cref< M T::*, 0 >
1637 {
1638     typedef M type;
1639 };
1640
1641 template< class M, class T > struct add_cref< M T::*, 1 >
1642 {
1643     typedef M const & type;
1644 };
1645
1646 template< class R, class T > struct add_cref< R (T::*) (), 1 >
1647 {
1648     typedef void type;
1649 };
1650
1651 #if !( defined(__IBMCPP__) && BOOST_WORKAROUND( __IBMCPP__, BOOST_TESTED_AT(600) ) )
1652
1653 template< class R, class T > struct add_cref< R (T::*) () const, 1 >
1654 {
1655     typedef void type;
1656 };
1657
1658 #endif // __IBMCPP__
1659
1660 template<class R> struct isref
1661 {
1662     enum value_type { value = 0 };
1663 };
1664
1665 template<class R> struct isref< R& >
1666 {
1667     enum value_type { value = 1 };
1668 };
1669
1670 template<class R> struct isref< R* >
1671 {
1672     enum value_type { value = 1 };
1673 };
1674
1675 template<class Pm, class A1> struct dm_result
1676 {
1677     typedef typename add_cref< Pm, 1 >::type type;
1678 };
1679
1680 template<class Pm, class R, class F, class L> struct dm_result< Pm, bind_t<R, F, L> >
1681 {
1682     typedef typename bind_t<R, F, L>::result_type result_type;
1683     typedef typename add_cref< Pm, isref< result_type >::value >::type type;
1684 };
1685
1686 } // namespace _bi
1687
1688 template< class A1, class M, class T >
1689
1690 _bi::bind_t<
1691     typename _bi::dm_result< M T::*, A1 >::type,
1692     _mfi::dm<M, T>,
1693     typename _bi::list_av_1<A1>::type
1694 >
1695
1696 BOOST_BIND( M T::*f, A1 a1 )
1697 {
1698     typedef typename _bi::dm_result< M T::*, A1 >::type result_type;
1699     typedef _mfi::dm<M, T> F;
1700     typedef typename _bi::list_av_1<A1>::type list_type;
1701     return _bi::bind_t< result_type, F, list_type >( F( f ), list_type( a1 ) );
1702 }
1703
1704 #endif
1705
1706 } // namespace boost
1707
1708 #ifndef BOOST_BIND_NO_PLACEHOLDERS
1709
1710 # include <boost/bind/placeholders.hpp>
1711
1712 #endif
1713
1714 #ifdef BOOST_MSVC
1715 # pragma warning(default: 4512) // assignment operator could not be generated
1716 # pragma warning(pop)
1717 #endif
1718
1719 #endif // #ifndef BOOST_BIND_HPP_INCLUDED