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