boost/boost/bind/bind.hpp

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