/extlibs/Boost/include/boost/bind/bind.hpp

Large files files are truncated, but you can click here to view the full file

   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
  48namespace boost
  49{
  50
  51template<class T> class weak_ptr;
  52
  53namespace _bi // implementation details
  54{
  55
  56// result_traits
  57
  58template<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
  65struct unspecified {};
  66
  67template<class F> struct result_traits<unspecified, F>
  68{
  69    typedef typename F::result_type type;
  70};
  71
  72template<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
  81template<class T> bool ref_compare( T const & a, T const & b, long )
  82{
  83    return a == b;
  84}
  85
  86template<int I> bool ref_compare( arg<I> const &, arg<I> const &, int )
  87{
  88    return true;
  89}
  90
  91template<int I> bool ref_compare( arg<I> (*) (), arg<I> (*) (), int )
  92{
  93    return true;
  94}
  95
  96template<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
 103template<class R, class F, class L> class bind_t;
 104
 105template<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
 112template<class T> class value
 113{
 114public:
 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
 126private:
 127
 128    T t_;
 129};
 130
 131// ref_compare for weak_ptr
 132
 133template<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
 140template<class T> class type {};
 141
 142// unwrap
 143
 144template<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
 164class list0
 165{
 166public:
 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
 217template< class A1 > class list1: private storage1< A1 >
 218{
 219private:
 220
 221    typedef storage1< A1 > base_type;
 222
 223public:
 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
 272struct logical_and;
 273struct logical_or;
 274
 275template< class A1, class A2 > class list2: private storage2< A1, A2 >
 276{
 277private:
 278
 279    typedef storage2< A1, A2 > base_type;
 280
 281public:
 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
 352template< class A1, class A2, class A3 > class list3: private storage3< A1, A2, A3 >
 353{
 354private:
 355
 356    typedef storage3< A1, A2, A3 > base_type;
 357
 358public:
 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
 415template< class A1, class A2, class A3, class A4 > class list4: private storage4< A1, A2, A3, A4 >
 416{
 417private:
 418
 419    typedef storage4< A1, A2, A3, A4 > base_type;
 420
 421public:
 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
 481template< class A1, class A2, class A3, class A4, class A5 > class list5: private storage5< A1, A2, A3, A4, A5 >
 482{
 483private:
 484
 485    typedef storage5< A1, A2, A3, A4, A5 > base_type;
 486
 487public:
 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
 550template<class A1, class A2, class A3, class A4, class A5, class A6> class list6: private storage6< A1, A2, A3, A4, A5, A6 >
 551{
 552private:
 553
 554    typedef storage6< A1, A2, A3, A4, A5, A6 > base_type;
 555
 556public:
 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
 622template<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{
 624private:
 625
 626    typedef storage7< A1, A2, A3, A4, A5, A6, A7 > base_type;
 627
 628public:
 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
 697template< 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{
 699private:
 700
 701    typedef storage8< A1, A2, A3, A4, A5, A6, A7, A8 > base_type;
 702
 703public:
 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
 775template<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{
 777private:
 778
 779    typedef storage9< A1, A2, A3, A4, A5, A6, A7, A8, A9 > base_type;
 780
 781public:
 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
 864template<class R, class F, class L> class bind_t
 865{
 866public:
 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
 880template<class R> struct bind_t_generator
 881{
 882
 883template<class F, class L> class implementation
 884{
 885public:
 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
 899template<> struct bind_t_generator<void>
 900{
 901
 902template<class F, class L> class implementation
 903{
 904private:
 905
 906    typedef void R;
 907
 908public:
 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
 922template<class R2, class F, class L> class bind_t: public bind_t_generator<R2>::BOOST_NESTED_TEMPLATE implementation<F, L>
 923{
 924public:
 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
 940template<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
 947template<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
 962template<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
 969template<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
 976namespace _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
 987template<class T> struct add_value
 988{
 989    typedef _bi::value<T> type;
 990};
 991
 992#else
 993
 994template< class T, int I > struct add_value_2
 995{
 996    typedef boost::arg<I> type;
 997};
 998
 999template< class T > struct add_value_2< T, 0 >
1000{
1001    typedef _bi::value< T > type;
1002};
1003
1004template<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
1011template<class T> struct add_value< value<T> >
1012{
1013    typedef _bi::value<T> type;
1014};
1015
1016template<class T> struct add_value< reference_wrapper<T> >
1017{
1018    typedef reference_wrapper<T> type;
1019};
1020
1021template<int I> struct add_value< arg<I> >
1022{
1023    typedef boost::arg<I> type;
1024};
1025
1026template<int I> struct add_value< arg<I> (*) () >
1027{
1028    typedef boost::arg<I> (*type) ();
1029};
1030
1031template<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
1038template<int I> struct _avt_0;
1039
1040template<> struct _avt_0<1>
1041{
1042    template<class T> struct inner
1043    {
1044        typedef T type;
1045    };
1046};
1047
1048template<> struct _avt_0<2>
1049{
1050    template<class T> struct inner
1051    {
1052        typedef value<T> type;
1053    };
1054};
1055
1056typedef char (&_avt_r1) [1];
1057typedef char (&_avt_r2) [2];
1058
1059template<class T> _avt_r1 _avt_f(value<T>);
1060template<class T> _avt_r1 _avt_f(reference_wrapper<T>);
1061template<int I> _avt_r1 _avt_f(arg<I>);
1062template<int I> _avt_r1 _avt_f(arg<I> (*) ());
1063template<class R, class F, class L> _avt_r1 _avt_f(bind_t<R, F, L>);
1064
1065_avt_r2 _avt_f(...);
1066
1067template<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
1077template<class A1> struct list_av_1
1078{
1079    typedef typename add_value<A1>::type B1;
1080    typedef list1<B1> type;
1081};
1082
1083template<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
1090template<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
1098template<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
1107template<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
1117template<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
1128template<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
1140template<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
1153template<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
1169struct logical_not
1170{
1171    template<class V> bool operator()(V const & v) const { return !v; }
1172};
1173
1174template<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\
1186struct name \
1187{ \
1188    template<class V, class W> bool operator()(V const & v, W const & w) const { return v op w; } \
1189}; \
1190 \
1191template<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
1200BOOST_BIND_OPERATOR( ==, equal )
1201BOOST_BIND_OPERATOR( !=, not_equal )
1202
1203BOOST_BIND_OPERATOR( <, less )
1204BOOST_BIND_OPERATOR( <=, less_equal )
1205
1206BOOST_BIND_OPERATOR( >, greater )
1207BOOST_BIND_OPERATOR( >=, greater_equal )
1208
1209BOOST_BIND_OPERATOR( &&, logical_and )
1210BOOST_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\
1220template<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
1228BOOST_BIND_OPERATOR( !=, not_equal )
1229BOOST_BIND_OPERATOR( <=, less_equal )
1230BOOST_BIND_OPERATOR( >, greater )
1231BOOST_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
1240template<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
1246template<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
1260template<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
1265template<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
1274template< class T > struct is_bind_expression
1275{
1276    enum _vt { value = 0 };
1277};
1278
1279#if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
1280
1281template< 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
1296template<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
1304template<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
1312template<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
1320template<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
1328template<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
1336template<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
1344template<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
1352template<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
1360template<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
1368template<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
1378template<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
1386template<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
1394template<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
1402template<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
1410template<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
1418template<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
1426template<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
1434template<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
1442template<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
1450template<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
1462template<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
1470template<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_…