boost/boost/bind/bind.hpp

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