1 #ifndef BOOST_BIND_BIND_HPP_INCLUDED 2 #define BOOST_BIND_BIND_HPP_INCLUDED 3 4 // MS compatible compilers support #pragma once 5 6 #if defined(_MSC_VER) && (_MSC_VER >= 1020) 7 # pragma once 8 #endif 9 10 // 11 // bind.hpp - binds function objects to arguments 12 // 13 // Copyright (c) 2001-2004 Peter Dimov and Multi Media Ltd. 14 // Copyright (c) 2001 David Abrahams 15 // Copyright (c) 2005 Peter Dimov 16 // 17 // Distributed under the Boost Software License, Version 1.0. (See 18 // accompanying file LICENSE_1_0.txt or copy at 19 // http://www.boost.org/LICENSE_1_0.txt) 20 // 21 // See http://www.boost.org/libs/bind/bind.html for documentation. 22 // 23 24 #include <boost/config.hpp> 25 #include <boost/ref.hpp> 26 #include <boost/mem_fn.hpp> 27 #include <boost/type.hpp> 28 #include <boost/is_placeholder.hpp> 29 #include <boost/bind/arg.hpp> 30 #include <boost/detail/workaround.hpp> 31 #include <boost/visit_each.hpp> 32 #include <boost/core/enable_if.hpp> 33 #include <boost/core/is_same.hpp> 34 35 #if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) 36 #include <utility> // std::forward 37 #endif 38 39 // Borland-specific bug, visit_each() silently fails to produce code 40 41 #if defined(__BORLANDC__) 42 # define BOOST_BIND_VISIT_EACH boost::visit_each 43 #else 44 # define BOOST_BIND_VISIT_EACH visit_each 45 #endif 46 47 #include <boost/bind/storage.hpp> 48 49 #ifdef BOOST_MSVC 50 # pragma warning(push) 51 # pragma warning(disable: 4512) // assignment operator could not be generated 52 #endif 53 54 namespace boost 55 { 56 57 template<class T> class weak_ptr; 58 59 namespace _bi // implementation details 60 { 61 62 // result_traits 63 64 template<class R, class F> struct result_traits 65 { 66 typedef R type; 67 }; 68 69 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) 70 71 struct unspecified {}; 72 73 template<class F> struct result_traits<unspecified, F> 74 { 75 typedef typename F::result_type type; 76 }; 77 78 template<class F> struct result_traits< unspecified, reference_wrapper<F> > 79 { 80 typedef typename F::result_type type; 81 }; 82 83 #endif 84 85 // ref_compare 86 87 template<class T> bool ref_compare( T const & a, T const & b, long ) 88 { 89 return a == b; 90 } 91 92 template<int I> bool ref_compare( arg<I> const &, arg<I> const &, int ) 93 { 94 return true; 95 } 96 97 template<int I> bool ref_compare( arg<I> (*) (), arg<I> (*) (), int ) 98 { 99 return true; 100 } 101 102 template<class T> bool ref_compare( reference_wrapper<T> const & a, reference_wrapper<T> const & b, int ) 103 { 104 return a.get_pointer() == b.get_pointer(); 105 } 106 107 // bind_t forward declaration for listN 108 109 template<class R, class F, class L> class bind_t; 110 111 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 ) 112 { 113 return a.compare( b ); 114 } 115 116 // value 117 118 template<class T> class value 119 { 120 public: 121 122 value(T const & t): t_(t) {} 123 124 T & get() { return t_; } 125 T const & get() const { return t_; } 126 127 bool operator==(value const & rhs) const 128 { 129 return t_ == rhs.t_; 130 } 131 132 private: 133 134 T t_; 135 }; 136 137 // ref_compare for weak_ptr 138 139 template<class T> bool ref_compare( value< weak_ptr<T> > const & a, value< weak_ptr<T> > const & b, int ) 140 { 141 return !(a.get() < b.get()) && !(b.get() < a.get()); 142 } 143 144 // type 145 146 template<class T> class type {}; 147 148 // unwrap 149 150 template<class F> struct unwrapper 151 { 152 static inline F & unwrap( F & f, long ) 153 { 154 return f; 155 } 156 157 template<class F2> static inline F2 & unwrap( reference_wrapper<F2> rf, int ) 158 { 159 return rf.get(); 160 } 161 162 template<class R, class T> static inline _mfi::dm<R, T> unwrap( R T::* pm, int ) 163 { 164 return _mfi::dm<R, T>( pm ); 165 } 166 }; 167 168 // listN 169 170 class list0 171 { 172 public: 173 174 list0() {} 175 176 template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); } 177 178 template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); } 179 180 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); } 181 182 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); } 183 184 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); } 185 186 template<class R, class F, class A> R operator()(type<R>, F & f, A &, long) 187 { 188 return unwrapper<F>::unwrap(f, 0)(); 189 } 190 191 template<class R, class F, class A> R operator()(type<R>, F const & f, A &, long) const 192 { 193 return unwrapper<F const>::unwrap(f, 0)(); 194 } 195 196 template<class F, class A> void operator()(type<void>, F & f, A &, int) 197 { 198 unwrapper<F>::unwrap(f, 0)(); 199 } 200 201 template<class F, class A> void operator()(type<void>, F const & f, A &, int) const 202 { 203 unwrapper<F const>::unwrap(f, 0)(); 204 } 205 206 template<class V> void accept(V &) const 207 { 208 } 209 210 bool operator==(list0 const &) const 211 { 212 return true; 213 } 214 }; 215 216 #ifdef BOOST_MSVC 217 // MSVC is bright enough to realise that the parameter rhs 218 // in operator==may be unused for some template argument types: 219 #pragma warning(push) 220 #pragma warning(disable:4100) 221 #endif 222 223 template< class A1 > class list1: private storage1< A1 > 224 { 225 private: 226 227 typedef storage1< A1 > base_type; 228 229 public: 230 231 explicit list1( A1 a1 ): base_type( a1 ) {} 232 233 A1 operator[] (boost::arg<1>) const { return base_type::a1_; } 234 235 A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; } 236 237 template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); } 238 239 template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); } 240 241 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); } 242 243 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); } 244 245 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); } 246 247 template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long) 248 { 249 return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_]); 250 } 251 252 template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const 253 { 254 return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_]); 255 } 256 257 template<class F, class A> void operator()(type<void>, F & f, A & a, int) 258 { 259 unwrapper<F>::unwrap(f, 0)(a[base_type::a1_]); 260 } 261 262 template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const 263 { 264 unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_]); 265 } 266 267 template<class V> void accept(V & v) const 268 { 269 base_type::accept(v); 270 } 271 272 bool operator==(list1 const & rhs) const 273 { 274 return ref_compare(base_type::a1_, rhs.a1_, 0); 275 } 276 }; 277 278 struct logical_and; 279 struct logical_or; 280 281 template< class A1, class A2 > class list2: private storage2< A1, A2 > 282 { 283 private: 284 285 typedef storage2< A1, A2 > base_type; 286 287 public: 288 289 list2( A1 a1, A2 a2 ): base_type( a1, a2 ) {} 290 291 A1 operator[] (boost::arg<1>) const { return base_type::a1_; } 292 A2 operator[] (boost::arg<2>) const { return base_type::a2_; } 293 294 A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; } 295 A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; } 296 297 template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); } 298 299 template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); } 300 301 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); } 302 303 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); } 304 305 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); } 306 307 template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long) 308 { 309 return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]); 310 } 311 312 template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const 313 { 314 return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]); 315 } 316 317 template<class F, class A> void operator()(type<void>, F & f, A & a, int) 318 { 319 unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]); 320 } 321 322 template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const 323 { 324 unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]); 325 } 326 327 template<class A> bool operator()( type<bool>, logical_and & /*f*/, A & a, int ) 328 { 329 return a[ base_type::a1_ ] && a[ base_type::a2_ ]; 330 } 331 332 template<class A> bool operator()( type<bool>, logical_and const & /*f*/, A & a, int ) const 333 { 334 return a[ base_type::a1_ ] && a[ base_type::a2_ ]; 335 } 336 337 template<class A> bool operator()( type<bool>, logical_or & /*f*/, A & a, int ) 338 { 339 return a[ base_type::a1_ ] || a[ base_type::a2_ ]; 340 } 341 342 template<class A> bool operator()( type<bool>, logical_or const & /*f*/, A & a, int ) const 343 { 344 return a[ base_type::a1_ ] || a[ base_type::a2_ ]; 345 } 346 347 template<class V> void accept(V & v) const 348 { 349 base_type::accept(v); 350 } 351 352 bool operator==(list2 const & rhs) const 353 { 354 return ref_compare(base_type::a1_, rhs.a1_, 0) && ref_compare(base_type::a2_, rhs.a2_, 0); 355 } 356 }; 357 358 template< class A1, class A2, class A3 > class list3: private storage3< A1, A2, A3 > 359 { 360 private: 361 362 typedef storage3< A1, A2, A3 > base_type; 363 364 public: 365 366 list3( A1 a1, A2 a2, A3 a3 ): base_type( a1, a2, a3 ) {} 367 368 A1 operator[] (boost::arg<1>) const { return base_type::a1_; } 369 A2 operator[] (boost::arg<2>) const { return base_type::a2_; } 370 A3 operator[] (boost::arg<3>) const { return base_type::a3_; } 371 372 A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; } 373 A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; } 374 A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; } 375 376 template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); } 377 378 template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); } 379 380 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); } 381 382 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); } 383 384 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); } 385 386 template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long) 387 { 388 return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]); 389 } 390 391 template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const 392 { 393 return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]); 394 } 395 396 template<class F, class A> void operator()(type<void>, F & f, A & a, int) 397 { 398 unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]); 399 } 400 401 template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const 402 { 403 unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]); 404 } 405 406 template<class V> void accept(V & v) const 407 { 408 base_type::accept(v); 409 } 410 411 bool operator==(list3 const & rhs) const 412 { 413 return 414 415 ref_compare( base_type::a1_, rhs.a1_, 0 ) && 416 ref_compare( base_type::a2_, rhs.a2_, 0 ) && 417 ref_compare( base_type::a3_, rhs.a3_, 0 ); 418 } 419 }; 420 421 template< class A1, class A2, class A3, class A4 > class list4: private storage4< A1, A2, A3, A4 > 422 { 423 private: 424 425 typedef storage4< A1, A2, A3, A4 > base_type; 426 427 public: 428 429 list4( A1 a1, A2 a2, A3 a3, A4 a4 ): base_type( a1, a2, a3, a4 ) {} 430 431 A1 operator[] (boost::arg<1>) const { return base_type::a1_; } 432 A2 operator[] (boost::arg<2>) const { return base_type::a2_; } 433 A3 operator[] (boost::arg<3>) const { return base_type::a3_; } 434 A4 operator[] (boost::arg<4>) const { return base_type::a4_; } 435 436 A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; } 437 A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; } 438 A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; } 439 A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; } 440 441 template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); } 442 443 template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); } 444 445 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); } 446 447 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); } 448 449 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); } 450 451 template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long) 452 { 453 return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]); 454 } 455 456 template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const 457 { 458 return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]); 459 } 460 461 template<class F, class A> void operator()(type<void>, F & f, A & a, int) 462 { 463 unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]); 464 } 465 466 template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const 467 { 468 unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]); 469 } 470 471 template<class V> void accept(V & v) const 472 { 473 base_type::accept(v); 474 } 475 476 bool operator==(list4 const & rhs) const 477 { 478 return 479 480 ref_compare( base_type::a1_, rhs.a1_, 0 ) && 481 ref_compare( base_type::a2_, rhs.a2_, 0 ) && 482 ref_compare( base_type::a3_, rhs.a3_, 0 ) && 483 ref_compare( base_type::a4_, rhs.a4_, 0 ); 484 } 485 }; 486 487 template< class A1, class A2, class A3, class A4, class A5 > class list5: private storage5< A1, A2, A3, A4, A5 > 488 { 489 private: 490 491 typedef storage5< A1, A2, A3, A4, A5 > base_type; 492 493 public: 494 495 list5( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5 ): base_type( a1, a2, a3, a4, a5 ) {} 496 497 A1 operator[] (boost::arg<1>) const { return base_type::a1_; } 498 A2 operator[] (boost::arg<2>) const { return base_type::a2_; } 499 A3 operator[] (boost::arg<3>) const { return base_type::a3_; } 500 A4 operator[] (boost::arg<4>) const { return base_type::a4_; } 501 A5 operator[] (boost::arg<5>) const { return base_type::a5_; } 502 503 A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; } 504 A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; } 505 A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; } 506 A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; } 507 A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; } 508 509 template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); } 510 511 template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); } 512 513 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); } 514 515 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); } 516 517 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); } 518 519 template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long) 520 { 521 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_]); 522 } 523 524 template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const 525 { 526 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_]); 527 } 528 529 template<class F, class A> void operator()(type<void>, F & f, A & a, int) 530 { 531 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_]); 532 } 533 534 template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const 535 { 536 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_]); 537 } 538 539 template<class V> void accept(V & v) const 540 { 541 base_type::accept(v); 542 } 543 544 bool operator==(list5 const & rhs) const 545 { 546 return 547 548 ref_compare( base_type::a1_, rhs.a1_, 0 ) && 549 ref_compare( base_type::a2_, rhs.a2_, 0 ) && 550 ref_compare( base_type::a3_, rhs.a3_, 0 ) && 551 ref_compare( base_type::a4_, rhs.a4_, 0 ) && 552 ref_compare( base_type::a5_, rhs.a5_, 0 ); 553 } 554 }; 555 556 template<class A1, class A2, class A3, class A4, class A5, class A6> class list6: private storage6< A1, A2, A3, A4, A5, A6 > 557 { 558 private: 559 560 typedef storage6< A1, A2, A3, A4, A5, A6 > base_type; 561 562 public: 563 564 list6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6 ): base_type( a1, a2, a3, a4, a5, a6 ) {} 565 566 A1 operator[] (boost::arg<1>) const { return base_type::a1_; } 567 A2 operator[] (boost::arg<2>) const { return base_type::a2_; } 568 A3 operator[] (boost::arg<3>) const { return base_type::a3_; } 569 A4 operator[] (boost::arg<4>) const { return base_type::a4_; } 570 A5 operator[] (boost::arg<5>) const { return base_type::a5_; } 571 A6 operator[] (boost::arg<6>) const { return base_type::a6_; } 572 573 A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; } 574 A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; } 575 A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; } 576 A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; } 577 A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; } 578 A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; } 579 580 template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); } 581 582 template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); } 583 584 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); } 585 586 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); } 587 588 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); } 589 590 template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long) 591 { 592 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_]); 593 } 594 595 template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const 596 { 597 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_]); 598 } 599 600 template<class F, class A> void operator()(type<void>, F & f, A & a, int) 601 { 602 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_]); 603 } 604 605 template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const 606 { 607 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_]); 608 } 609 610 template<class V> void accept(V & v) const 611 { 612 base_type::accept(v); 613 } 614 615 bool operator==(list6 const & rhs) const 616 { 617 return 618 619 ref_compare( base_type::a1_, rhs.a1_, 0 ) && 620 ref_compare( base_type::a2_, rhs.a2_, 0 ) && 621 ref_compare( base_type::a3_, rhs.a3_, 0 ) && 622 ref_compare( base_type::a4_, rhs.a4_, 0 ) && 623 ref_compare( base_type::a5_, rhs.a5_, 0 ) && 624 ref_compare( base_type::a6_, rhs.a6_, 0 ); 625 } 626 }; 627 628 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 > 629 { 630 private: 631 632 typedef storage7< A1, A2, A3, A4, A5, A6, A7 > base_type; 633 634 public: 635 636 list7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7 ): base_type( a1, a2, a3, a4, a5, a6, a7 ) {} 637 638 A1 operator[] (boost::arg<1>) const { return base_type::a1_; } 639 A2 operator[] (boost::arg<2>) const { return base_type::a2_; } 640 A3 operator[] (boost::arg<3>) const { return base_type::a3_; } 641 A4 operator[] (boost::arg<4>) const { return base_type::a4_; } 642 A5 operator[] (boost::arg<5>) const { return base_type::a5_; } 643 A6 operator[] (boost::arg<6>) const { return base_type::a6_; } 644 A7 operator[] (boost::arg<7>) const { return base_type::a7_; } 645 646 A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; } 647 A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; } 648 A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; } 649 A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; } 650 A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; } 651 A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; } 652 A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; } 653 654 template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); } 655 656 template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); } 657 658 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); } 659 660 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); } 661 662 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); } 663 664 template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long) 665 { 666 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_]); 667 } 668 669 template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const 670 { 671 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_]); 672 } 673 674 template<class F, class A> void operator()(type<void>, F & f, A & a, int) 675 { 676 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_]); 677 } 678 679 template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const 680 { 681 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_]); 682 } 683 684 template<class V> void accept(V & v) const 685 { 686 base_type::accept(v); 687 } 688 689 bool operator==(list7 const & rhs) const 690 { 691 return 692 693 ref_compare( base_type::a1_, rhs.a1_, 0 ) && 694 ref_compare( base_type::a2_, rhs.a2_, 0 ) && 695 ref_compare( base_type::a3_, rhs.a3_, 0 ) && 696 ref_compare( base_type::a4_, rhs.a4_, 0 ) && 697 ref_compare( base_type::a5_, rhs.a5_, 0 ) && 698 ref_compare( base_type::a6_, rhs.a6_, 0 ) && 699 ref_compare( base_type::a7_, rhs.a7_, 0 ); 700 } 701 }; 702 703 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 > 704 { 705 private: 706 707 typedef storage8< A1, A2, A3, A4, A5, A6, A7, A8 > base_type; 708 709 public: 710 711 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 ) {} 712 713 A1 operator[] (boost::arg<1>) const { return base_type::a1_; } 714 A2 operator[] (boost::arg<2>) const { return base_type::a2_; } 715 A3 operator[] (boost::arg<3>) const { return base_type::a3_; } 716 A4 operator[] (boost::arg<4>) const { return base_type::a4_; } 717 A5 operator[] (boost::arg<5>) const { return base_type::a5_; } 718 A6 operator[] (boost::arg<6>) const { return base_type::a6_; } 719 A7 operator[] (boost::arg<7>) const { return base_type::a7_; } 720 A8 operator[] (boost::arg<8>) const { return base_type::a8_; } 721 722 A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; } 723 A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; } 724 A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; } 725 A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; } 726 A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; } 727 A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; } 728 A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; } 729 A8 operator[] (boost::arg<8> (*) ()) const { return base_type::a8_; } 730 731 template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); } 732 733 template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); } 734 735 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); } 736 737 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); } 738 739 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); } 740 741 template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long) 742 { 743 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_]); 744 } 745 746 template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const 747 { 748 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_]); 749 } 750 751 template<class F, class A> void operator()(type<void>, F & f, A & a, int) 752 { 753 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_]); 754 } 755 756 template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const 757 { 758 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_]); 759 } 760 761 template<class V> void accept(V & v) const 762 { 763 base_type::accept(v); 764 } 765 766 bool operator==(list8 const & rhs) const 767 { 768 return 769 770 ref_compare( base_type::a1_, rhs.a1_, 0 ) && 771 ref_compare( base_type::a2_, rhs.a2_, 0 ) && 772 ref_compare( base_type::a3_, rhs.a3_, 0 ) && 773 ref_compare( base_type::a4_, rhs.a4_, 0 ) && 774 ref_compare( base_type::a5_, rhs.a5_, 0 ) && 775 ref_compare( base_type::a6_, rhs.a6_, 0 ) && 776 ref_compare( base_type::a7_, rhs.a7_, 0 ) && 777 ref_compare( base_type::a8_, rhs.a8_, 0 ); 778 } 779 }; 780 781 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 > 782 { 783 private: 784 785 typedef storage9< A1, A2, A3, A4, A5, A6, A7, A8, A9 > base_type; 786 787 public: 788 789 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 ) {} 790 791 A1 operator[] (boost::arg<1>) const { return base_type::a1_; } 792 A2 operator[] (boost::arg<2>) const { return base_type::a2_; } 793 A3 operator[] (boost::arg<3>) const { return base_type::a3_; } 794 A4 operator[] (boost::arg<4>) const { return base_type::a4_; } 795 A5 operator[] (boost::arg<5>) const { return base_type::a5_; } 796 A6 operator[] (boost::arg<6>) const { return base_type::a6_; } 797 A7 operator[] (boost::arg<7>) const { return base_type::a7_; } 798 A8 operator[] (boost::arg<8>) const { return base_type::a8_; } 799 A9 operator[] (boost::arg<9>) const { return base_type::a9_; } 800 801 A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; } 802 A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; } 803 A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; } 804 A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; } 805 A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; } 806 A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; } 807 A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; } 808 A8 operator[] (boost::arg<8> (*) ()) const { return base_type::a8_; } 809 A9 operator[] (boost::arg<9> (*) ()) const { return base_type::a9_; } 810 811 template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); } 812 813 template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); } 814 815 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); } 816 817 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); } 818 819 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); } 820 821 template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long) 822 { 823 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_]); 824 } 825 826 template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const 827 { 828 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_]); 829 } 830 831 template<class F, class A> void operator()(type<void>, F & f, A & a, int) 832 { 833 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_]); 834 } 835 836 template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const 837 { 838 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_]); 839 } 840 841 template<class V> void accept(V & v) const 842 { 843 base_type::accept(v); 844 } 845 846 bool operator==(list9 const & rhs) const 847 { 848 return 849 850 ref_compare( base_type::a1_, rhs.a1_, 0 ) && 851 ref_compare( base_type::a2_, rhs.a2_, 0 ) && 852 ref_compare( base_type::a3_, rhs.a3_, 0 ) && 853 ref_compare( base_type::a4_, rhs.a4_, 0 ) && 854 ref_compare( base_type::a5_, rhs.a5_, 0 ) && 855 ref_compare( base_type::a6_, rhs.a6_, 0 ) && 856 ref_compare( base_type::a7_, rhs.a7_, 0 ) && 857 ref_compare( base_type::a8_, rhs.a8_, 0 ) && 858 ref_compare( base_type::a9_, rhs.a9_, 0 ); 859 } 860 }; 861 862 #ifdef BOOST_MSVC 863 #pragma warning(pop) 864 #endif 865 866 // bind_t 867 868 #if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) 869 870 template< class A1 > class rrlist1 871 { 872 private: 873 874 A1 & a1_; // not A1&& because of msvc-10.0 875 876 public: 877 878 explicit rrlist1( A1 & a1 ): a1_( a1 ) {} 879 880 A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); } // not static_cast because of g++ 4.9 881 882 A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); } 883 884 template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); } 885 886 template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); } 887 888 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); } 889 890 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const 891 { 892 rrlist1<A1&> a( a1_ ); 893 return b.eval( a ); 894 } 895 896 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const 897 { 898 rrlist1<A1&> a( a1_ ); 899 return b.eval( a ); 900 } 901 }; 902 903 template< class A1, class A2 > class rrlist2 904 { 905 private: 906 907 A1 & a1_; 908 A2 & a2_; 909 910 public: 911 912 rrlist2( A1 & a1, A2 & a2 ): a1_( a1 ), a2_( a2 ) {} 913 914 A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); } 915 A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); } 916 917 A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); } 918 A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); } 919 920 template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); } 921 922 template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); } 923 924 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); } 925 926 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const 927 { 928 rrlist2<A1&, A2&> a( a1_, a2_ ); 929 return b.eval( a ); 930 } 931 932 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const 933 { 934 rrlist2<A1&, A2&> a( a1_, a2_ ); 935 return b.eval( a ); 936 } 937 }; 938 939 template< class A1, class A2, class A3 > class rrlist3 940 { 941 private: 942 943 A1 & a1_; 944 A2 & a2_; 945 A3 & a3_; 946 947 public: 948 949 rrlist3( A1 & a1, A2 & a2, A3 & a3 ): a1_( a1 ), a2_( a2 ), a3_( a3 ) {} 950 951 A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); } 952 A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); } 953 A3 && operator[] (boost::arg<3>) const { return std::forward<A3>( a3_ ); } 954 955 A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); } 956 A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); } 957 A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( a3_ ); } 958 959 template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); } 960 961 template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); } 962 963 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); } 964 965 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const 966 { 967 rrlist3<A1&, A2&, A3&> a( a1_, a2_, a3_ ); 968 return b.eval( a ); 969 } 970 971 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const 972 { 973 rrlist3<A1&, A2&, A3&> a( a1_, a2_, a3_ ); 974 return b.eval( a ); 975 } 976 }; 977 978 template< class A1, class A2, class A3, class A4 > class rrlist4 979 { 980 private: 981 982 A1 & a1_; 983 A2 & a2_; 984 A3 & a3_; 985 A4 & a4_; 986 987 public: 988 989 rrlist4( A1 & a1, A2 & a2, A3 & a3, A4 & a4 ): a1_( a1 ), a2_( a2 ), a3_( a3 ), a4_( a4 ) {} 990 991 A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); } 992 A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); } 993 A3 && operator[] (boost::arg<3>) const { return std::forward<A3>( a3_ ); } 994 A4 && operator[] (boost::arg<4>) const { return std::forward<A4>( a4_ ); } 995 996 A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); } 997 A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); } 998 A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( a3_ ); } 999 A4 && operator[] (boost::arg<4> (*) ()) const { return std::forward<A4>( a4_ ); } 1000 1001 template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); } 1002 1003 template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); } 1004 1005 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); } 1006 1007 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const 1008 { 1009 rrlist4<A1&, A2&, A3&, A4&> a( a1_, a2_, a3_, a4_ ); 1010 return b.eval( a ); 1011 } 1012 1013 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const 1014 { 1015 rrlist4<A1&, A2&, A3&, A4&> a( a1_, a2_, a3_, a4_ ); 1016 return b.eval( a ); 1017 } 1018 }; 1019 1020 template< class A1, class A2, class A3, class A4, class A5 > class rrlist5 1021 { 1022 private: 1023 1024 A1 & a1_; 1025 A2 & a2_; 1026 A3 & a3_; 1027 A4 & a4_; 1028 A5 & a5_; 1029 1030 public: 1031 1032 rrlist5( A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5 ): a1_( a1 ), a2_( a2 ), a3_( a3 ), a4_( a4 ), a5_( a5 ) {} 1033 1034 A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); } 1035 A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); } 1036 A3 && operator[] (boost::arg<3>) const { return std::forward<A3>( a3_ ); } 1037 A4 && operator[] (boost::arg<4>) const { return std::forward<A4>( a4_ ); } 1038 A5 && operator[] (boost::arg<5>) const { return std::forward<A5>( a5_ ); } 1039 1040 A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); } 1041 A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); } 1042 A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( a3_ ); } 1043 A4 && operator[] (boost::arg<4> (*) ()) const { return std::forward<A4>( a4_ ); } 1044 A5 && operator[] (boost::arg<5> (*) ()) const { return std::forward<A5>( a5_ ); } 1045 1046 template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); } 1047 1048 template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); } 1049 1050 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); } 1051 1052 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const 1053 { 1054 rrlist5<A1&, A2&, A3&, A4&, A5&> a( a1_, a2_, a3_, a4_, a5_ ); 1055 return b.eval( a ); 1056 } 1057 1058 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const 1059 { 1060 rrlist5<A1&, A2&, A3&, A4&, A5&> a( a1_, a2_, a3_, a4_, a5_ ); 1061 return b.eval( a ); 1062 } 1063 }; 1064 1065 template< class A1, class A2, class A3, class A4, class A5, class A6 > class rrlist6 1066 { 1067 private: 1068 1069 A1 & a1_; 1070 A2 & a2_; 1071 A3 & a3_; 1072 A4 & a4_; 1073 A5 & a5_; 1074 A6 & a6_; 1075 1076 public: 1077 1078 rrlist6( A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6 ): a1_( a1 ), a2_( a2 ), a3_( a3 ), a4_( a4 ), a5_( a5 ), a6_( a6 ) {} 1079 1080 A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); } 1081 A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); } 1082 A3 && operator[] (boost::arg<3>) const { return std::forward<A3>( a3_ ); } 1083 A4 && operator[] (boost::arg<4>) const { return std::forward<A4>( a4_ ); } 1084 A5 && operator[] (boost::arg<5>) const { return std::forward<A5>( a5_ ); } 1085 A6 && operator[] (boost::arg<6>) const { return std::forward<A6>( a6_ ); } 1086 1087 A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); } 1088 A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); } 1089 A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( a3_ ); } 1090 A4 && operator[] (boost::arg<4> (*) ()) const { return std::forward<A4>( a4_ ); } 1091 A5 && operator[] (boost::arg<5> (*) ()) const { return std::forward<A5>( a5_ ); } 1092 A6 && operator[] (boost::arg<6> (*) ()) const { return std::forward<A6>( a6_ ); } 1093 1094 template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); } 1095 1096 template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); } 1097 1098 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); } 1099 1100 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const 1101 { 1102 rrlist6<A1&, A2&, A3&, A4&, A5&, A6&> a( a1_, a2_, a3_, a4_, a5_, a6_ ); 1103 return b.eval( a ); 1104 } 1105 1106 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const 1107 { 1108 rrlist6<A1&, A2&, A3&, A4&, A5&, A6&> a( a1_, a2_, a3_, a4_, a5_, a6_ ); 1109 return b.eval( a ); 1110 } 1111 }; 1112 1113 template< class A1, class A2, class A3, class A4, class A5, class A6, class A7 > class rrlist7 1114 { 1115 private: 1116 1117 A1 & a1_; 1118 A2 & a2_; 1119 A3 & a3_; 1120 A4 & a4_; 1121 A5 & a5_; 1122 A6 & a6_; 1123 A7 & a7_; 1124 1125 public: 1126 1127 rrlist7( A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7 ): a1_( a1 ), a2_( a2 ), a3_( a3 ), a4_( a4 ), a5_( a5 ), a6_( a6 ), a7_( a7 ) {} 1128 1129 A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); } 1130 A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); } 1131 A3 && operator[] (boost::arg<3>) const { return std::forward<A3>( a3_ ); } 1132 A4 && operator[] (boost::arg<4>) const { return std::forward<A4>( a4_ ); } 1133 A5 && operator[] (boost::arg<5>) const { return std::forward<A5>( a5_ ); } 1134 A6 && operator[] (boost::arg<6>) const { return std::forward<A6>( a6_ ); } 1135 A7 && operator[] (boost::arg<7>) const { return std::forward<A7>( a7_ ); } 1136 1137 A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); } 1138 A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); } 1139 A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( a3_ ); } 1140 A4 && operator[] (boost::arg<4> (*) ()) const { return std::forward<A4>( a4_ ); } 1141 A5 && operator[] (boost::arg<5> (*) ()) const { return std::forward<A5>( a5_ ); } 1142 A6 && operator[] (boost::arg<6> (*) ()) const { return std::forward<A6>( a6_ ); } 1143 A7 && operator[] (boost::arg<7> (*) ()) const { return std::forward<A7>( a7_ ); } 1144 1145 template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); } 1146 1147 template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); } 1148 1149 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); } 1150 1151 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const 1152 { 1153 rrlist7<A1&, A2&, A3&, A4&, A5&, A6&, A7&> a( a1_, a2_, a3_, a4_, a5_, a6_, a7_ ); 1154 return b.eval( a ); 1155 } 1156 1157 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const 1158 { 1159 rrlist7<A1&, A2&, A3&, A4&, A5&, A6&, A7&> a( a1_, a2_, a3_, a4_, a5_, a6_, a7_ ); 1160 return b.eval( a ); 1161 } 1162 }; 1163 1164 template< class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 > class rrlist8 1165 { 1166 private: 1167 1168 A1 & a1_; 1169 A2 & a2_; 1170 A3 & a3_; 1171 A4 & a4_; 1172 A5 & a5_; 1173 A6 & a6_; 1174 A7 & a7_; 1175 A8 & a8_; 1176 1177 public: 1178 1179 rrlist8( A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8 ): a1_( a1 ), a2_( a2 ), a3_( a3 ), a4_( a4 ), a5_( a5 ), a6_( a6 ), a7_( a7 ), a8_( a8 ) {} 1180 1181 A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); } 1182 A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); } 1183 A3 && operator[] (boost::arg<3>) const { return std::forward<A3>( a3_ ); } 1184 A4 && operator[] (boost::arg<4>) const { return std::forward<A4>( a4_ ); } 1185 A5 && operator[] (boost::arg<5>) const { return std::forward<A5>( a5_ ); } 1186 A6 && operator[] (boost::arg<6>) const { return std::forward<A6>( a6_ ); } 1187 A7 && operator[] (boost::arg<7>) const { return std::forward<A7>( a7_ ); } 1188 A8 && operator[] (boost::arg<8>) const { return std::forward<A8>( a8_ ); } 1189 1190 A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); } 1191 A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); } 1192 A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( a3_ ); } 1193 A4 && operator[] (boost::arg<4> (*) ()) const { return std::forward<A4>( a4_ ); } 1194 A5 && operator[] (boost::arg<5> (*) ()) const { return std::forward<A5>( a5_ ); } 1195 A6 && operator[] (boost::arg<6> (*) ()) const { return std::forward<A6>( a6_ ); } 1196 A7 && operator[] (boost::arg<7> (*) ()) const { return std::forward<A7>( a7_ ); } 1197 A8 && operator[] (boost::arg<8> (*) ()) const { return std::forward<A8>( a8_ ); } 1198 1199 template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); } 1200 1201 template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); } 1202 1203 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); } 1204 1205 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const 1206 { 1207 rrlist8<A1&, A2&, A3&, A4&, A5&, A6&, A7&, A8&> a( a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_ ); 1208 return b.eval( a ); 1209 } 1210 1211 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const 1212 { 1213 rrlist8<A1&, A2&, A3&, A4&, A5&, A6&, A7&, A8&> a( a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_ ); 1214 return b.eval( a ); 1215 } 1216 }; 1217 1218 template< class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 > class rrlist9 1219 { 1220 private: 1221 1222 A1 & a1_; 1223 A2 & a2_; 1224 A3 & a3_; 1225 A4 & a4_; 1226 A5 & a5_; 1227 A6 & a6_; 1228 A7 & a7_; 1229 A8 & a8_; 1230 A9 & a9_; 1231 1232 public: 1233 1234 rrlist9( A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9 ): a1_( a1 ), a2_( a2 ), a3_( a3 ), a4_( a4 ), a5_( a5 ), a6_( a6 ), a7_( a7 ), a8_( a8 ), a9_( a9 ) {} 1235 1236 A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); } 1237 A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); } 1238 A3 && operator[] (boost::arg<3>) const { return std::forward<A3>( a3_ ); } 1239 A4 && operator[] (boost::arg<4>) const { return std::forward<A4>( a4_ ); } 1240 A5 && operator[] (boost::arg<5>) const { return std::forward<A5>( a5_ ); } 1241 A6 && operator[] (boost::arg<6>) const { return std::forward<A6>( a6_ ); } 1242 A7 && operator[] (boost::arg<7>) const { return std::forward<A7>( a7_ ); } 1243 A8 && operator[] (boost::arg<8>) const { return std::forward<A8>( a8_ ); } 1244 A9 && operator[] (boost::arg<9>) const { return std::forward<A9>( a9_ ); } 1245 1246 A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); } 1247 A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); } 1248 A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( a3_ ); } 1249 A4 && operator[] (boost::arg<4> (*) ()) const { return std::forward<A4>( a4_ ); } 1250 A5 && operator[] (boost::arg<5> (*) ()) const { return std::forward<A5>( a5_ ); } 1251 A6 && operator[] (boost::arg<6> (*) ()) const { return std::forward<A6>( a6_ ); } 1252 A7 && operator[] (boost::arg<7> (*) ()) const { return std::forward<A7>( a7_ ); } 1253 A8 && operator[] (boost::arg<8> (*) ()) const { return std::forward<A8>( a8_ ); } 1254 A9 && operator[] (boost::arg<9> (*) ()) const { return std::forward<A9>( a9_ ); } 1255 1256 template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); } 1257 1258 template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); } 1259 1260 template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); } 1261 1262 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const 1263 { 1264 rrlist9<A1&, A2&, A3&, A4&, A5&, A6&, A7&, A8&, A9&> a( a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_, a9_ ); 1265 return b.eval( a ); 1266 } 1267 1268 template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const 1269 { 1270 rrlist9<A1&, A2&, A3&, A4&, A5&, A6&, A7&, A8&, A9&> a( a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_, a9_ ); 1271 return b.eval( a ); 1272 } 1273 }; 1274 1275 template<class R, class F, class L> class bind_t 1276 { 1277 private: 1278 1279 F f_; 1280 L l_; 1281 1282 public: 1283 1284 typedef typename result_traits<R, F>::type result_type; 1285 typedef bind_t this_type; 1286 1287 bind_t( F f, L const & l ): f_( f ), l_( l ) {} 1288 1289 // 1290 1291 result_type operator()() 1292 { 1293 list0 a; 1294 return l_( type<result_type>(), f_, a, 0 ); 1295 } 1296 1297 result_type operator()() const 1298 { 1299 list0 a; 1300 return l_( type<result_type>(), f_, a, 0 ); 1301 } 1302 1303 template<class A1> result_type operator()( A1 && a1 ) 1304 { 1305 rrlist1< A1 > a( a1 ); 1306 return l_( type<result_type>(), f_, a, 0 ); 1307 } 1308 1309 template<class A1> result_type operator()( A1 && a1 ) const 1310 { 1311 rrlist1< A1 > a( a1 ); 1312 return l_(type<result_type>(), f_, a, 0); 1313 } 1314 1315 template<class A1, class A2> result_type operator()( A1 && a1, A2 && a2 ) 1316 { 1317 rrlist2< A1, A2 > a( a1, a2 ); 1318 return l_( type<result_type>(), f_, a, 0 ); 1319 } 1320 1321 template<class A1, class A2> result_type operator()( A1 && a1, A2 && a2 ) const 1322 { 1323 rrlist2< A1, A2 > a( a1, a2 ); 1324 return l_( type<result_type>(), f_, a, 0 ); 1325 } 1326 1327 template<class A1, class A2, class A3> result_type operator()( A1 && a1, A2 && a2, A3 && a3 ) 1328 { 1329 rrlist3< A1, A2, A3 > a( a1, a2, a3 ); 1330 return l_( type<result_type>(), f_, a, 0 ); 1331 } 1332 1333 template<class A1, class A2, class A3> result_type operator()( A1 && a1, A2 && a2, A3 && a3 ) const 1334 { 1335 rrlist3< A1, A2, A3 > a( a1, a2, a3 ); 1336 return l_( type<result_type>(), f_, a, 0 ); 1337 } 1338 1339 template<class A1, class A2, class A3, class A4> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4 ) 1340 { 1341 rrlist4< A1, A2, A3, A4 > a( a1, a2, a3, a4 ); 1342 return l_( type<result_type>(), f_, a, 0 ); 1343 } 1344 1345 template<class A1, class A2, class A3, class A4> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4 ) const 1346 { 1347 rrlist4< A1, A2, A3, A4 > a( a1, a2, a3, a4 ); 1348 return l_( type<result_type>(), f_, a, 0 ); 1349 } 1350 1351 template<class A1, class A2, class A3, class A4, class A5> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5 ) 1352 { 1353 rrlist5< A1, A2, A3, A4, A5 > a( a1, a2, a3, a4, a5 ); 1354 return l_( type<result_type>(), f_, a, 0 ); 1355 } 1356 1357 template<class A1, class A2, class A3, class A4, class A5> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5 ) const 1358 { 1359 rrlist5< A1, A2, A3, A4, A5 > a( a1, a2, a3, a4, a5 ); 1360 return l_( type<result_type>(), f_, a, 0 ); 1361 } 1362 1363 template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6 ) 1364 { 1365 rrlist6< A1, A2, A3, A4, A5, A6 > a( a1, a2, a3, a4, a5, a6 ); 1366 return l_( type<result_type>(), f_, a, 0 ); 1367 } 1368 1369 template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6 ) const 1370 { 1371 rrlist6< A1, A2, A3, A4, A5, A6 > a( a1, a2, a3, a4, a5, a6 ); 1372 return l_( type<result_type>(), f_, a, 0 ); 1373 } 1374 1375 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7 ) 1376 { 1377 rrlist7< A1, A2, A3, A4, A5, A6, A7 > a( a1, a2, a3, a4, a5, a6, a7 ); 1378 return l_( type<result_type>(), f_, a, 0 ); 1379 } 1380 1381 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7 ) const 1382 { 1383 rrlist7< A1, A2, A3, A4, A5, A6, A7 > a( a1, a2, a3, a4, a5, a6, a7 ); 1384 return l_( type<result_type>(), f_, a, 0 ); 1385 } 1386 1387 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8 ) 1388 { 1389 rrlist8< A1, A2, A3, A4, A5, A6, A7, A8 > a( a1, a2, a3, a4, a5, a6, a7, a8 ); 1390 return l_( type<result_type>(), f_, a, 0 ); 1391 } 1392 1393 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8 ) const 1394 { 1395 rrlist8< A1, A2, A3, A4, A5, A6, A7, A8 > a( a1, a2, a3, a4, a5, a6, a7, a8 ); 1396 return l_( type<result_type>(), f_, a, 0 ); 1397 } 1398 1399 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8, A9 && a9 ) 1400 { 1401 rrlist9< A1, A2, A3, A4, A5, A6, A7, A8, A9 > a( a1, a2, a3, a4, a5, a6, a7, a8, a9 ); 1402 return l_( type<result_type>(), f_, a, 0 ); 1403 } 1404 1405 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8, A9 && a9 ) const 1406 { 1407 rrlist9< A1, A2, A3, A4, A5, A6, A7, A8, A9 > a( a1, a2, a3, a4, a5, a6, a7, a8, a9 ); 1408 return l_( type<result_type>(), f_, a, 0 ); 1409 } 1410 1411 // 1412 1413 template<class A> result_type eval( A & a ) 1414 { 1415 return l_( type<result_type>(), f_, a, 0 ); 1416 } 1417 1418 template<class A> result_type eval( A & a ) const 1419 { 1420 return l_( type<result_type>(), f_, a, 0 ); 1421 } 1422 1423 template<class V> void accept( V & v ) const 1424 { 1425 #if !defined( BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP ) && !defined( __BORLANDC__ ) 1426 using boost::visit_each; 1427 #endif 1428 1429 BOOST_BIND_VISIT_EACH( v, f_, 0 ); 1430 l_.accept( v ); 1431 } 1432 1433 bool compare( this_type const & rhs ) const 1434 { 1435 return ref_compare( f_, rhs.f_, 0 ) && l_ == rhs.l_; 1436 } 1437 }; 1438 1439 #elif !defined( BOOST_NO_VOID_RETURNS ) 1440 1441 template<class R, class F, class L> class bind_t 1442 { 1443 public: 1444 1445 typedef bind_t this_type; 1446 1447 bind_t(F f, L const & l): f_(f), l_(l) {} 1448 1449 #define BOOST_BIND_RETURN return 1450 #include <boost/bind/bind_template.hpp> 1451 #undef BOOST_BIND_RETURN 1452 1453 }; 1454 1455 #else // no void returns 1456 1457 template<class R> struct bind_t_generator 1458 { 1459 1460 template<class F, class L> class implementation 1461 { 1462 public: 1463 1464 typedef implementation this_type; 1465 1466 implementation(F f, L const & l): f_(f), l_(l) {} 1467 1468 #define BOOST_BIND_RETURN return 1469 #include <boost/bind/bind_template.hpp> 1470 #undef BOOST_BIND_RETURN 1471 1472 }; 1473 1474 }; 1475 1476 template<> struct bind_t_generator<void> 1477 { 1478 1479 template<class F, class L> class implementation 1480 { 1481 private: 1482 1483 typedef void R; 1484 1485 public: 1486 1487 typedef implementation this_type; 1488 1489 implementation(F f, L const & l): f_(f), l_(l) {} 1490 1491 #define BOOST_BIND_RETURN 1492 #include <boost/bind/bind_template.hpp> 1493 #undef BOOST_BIND_RETURN 1494 1495 }; 1496 1497 }; 1498 1499 template<class R2, class F, class L> class bind_t: public bind_t_generator<R2>::BOOST_NESTED_TEMPLATE implementation<F, L> 1500 { 1501 public: 1502 1503 bind_t(F f, L const & l): bind_t_generator<R2>::BOOST_NESTED_TEMPLATE implementation<F, L>(f, l) {} 1504 1505 }; 1506 1507 #endif 1508 1509 // function_equal 1510 1511 #ifndef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP 1512 1513 // put overloads in _bi, rely on ADL 1514 1515 # ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING 1516 1517 template<class R, class F, class L> bool function_equal( bind_t<R, F, L> const & a, bind_t<R, F, L> const & b ) 1518 { 1519 return a.compare(b); 1520 } 1521 1522 # else 1523 1524 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 ) 1525 { 1526 return a.compare(b); 1527 } 1528 1529 # endif // #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING 1530 1531 #else // BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP 1532 1533 // put overloads in boost 1534 1535 } // namespace _bi 1536 1537 # ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING 1538 1539 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 ) 1540 { 1541 return a.compare(b); 1542 } 1543 1544 # else 1545 1546 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 ) 1547 { 1548 return a.compare(b); 1549 } 1550 1551 # endif // #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING 1552 1553 namespace _bi 1554 { 1555 1556 #endif // BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP 1557 1558 // add_value 1559 1560 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) || (__SUNPRO_CC >= 0x530) 1561 1562 #if defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x582) ) 1563 1564 template<class T> struct add_value 1565 { 1566 typedef _bi::value<T> type; 1567 }; 1568 1569 #else 1570 1571 template< class T, int I > struct add_value_2 1572 { 1573 typedef boost::arg<I> type; 1574 }; 1575 1576 template< class T > struct add_value_2< T, 0 > 1577 { 1578 typedef _bi::value< T > type; 1579 }; 1580 1581 template<class T> struct add_value 1582 { 1583 typedef typename add_value_2< T, boost::is_placeholder< T >::value >::type type; 1584 }; 1585 1586 #endif 1587 1588 template<class T> struct add_value< value<T> > 1589 { 1590 typedef _bi::value<T> type; 1591 }; 1592 1593 template<class T> struct add_value< reference_wrapper<T> > 1594 { 1595 typedef reference_wrapper<T> type; 1596 }; 1597 1598 template<int I> struct add_value< arg<I> > 1599 { 1600 typedef boost::arg<I> type; 1601 }; 1602 1603 template<int I> struct add_value< arg<I> (*) () > 1604 { 1605 typedef boost::arg<I> (*type) (); 1606 }; 1607 1608 template<class R, class F, class L> struct add_value< bind_t<R, F, L> > 1609 { 1610 typedef bind_t<R, F, L> type; 1611 }; 1612 1613 #else 1614 1615 template<int I> struct _avt_0; 1616 1617 template<> struct _avt_0<1> 1618 { 1619 template<class T> struct inner 1620 { 1621 typedef T type; 1622 }; 1623 }; 1624 1625 template<> struct _avt_0<2> 1626 { 1627 template<class T> struct inner 1628 { 1629 typedef value<T> type; 1630 }; 1631 }; 1632 1633 typedef char (&_avt_r1) [1]; 1634 typedef char (&_avt_r2) [2]; 1635 1636 template<class T> _avt_r1 _avt_f(value<T>); 1637 template<class T> _avt_r1 _avt_f(reference_wrapper<T>); 1638 template<int I> _avt_r1 _avt_f(arg<I>); 1639 template<int I> _avt_r1 _avt_f(arg<I> (*) ()); 1640 template<class R, class F, class L> _avt_r1 _avt_f(bind_t<R, F, L>); 1641 1642 _avt_r2 _avt_f(...); 1643 1644 template<class T> struct add_value 1645 { 1646 static T t(); 1647 typedef typename _avt_0<sizeof(_avt_f(t()))>::template inner<T>::type type; 1648 }; 1649 1650 #endif 1651 1652 // list_av_N 1653 1654 template<class A1> struct list_av_1 1655 { 1656 typedef typename add_value<A1>::type B1; 1657 typedef list1<B1> type; 1658 }; 1659 1660 template<class A1, class A2> struct list_av_2 1661 { 1662 typedef typename add_value<A1>::type B1; 1663 typedef typename add_value<A2>::type B2; 1664 typedef list2<B1, B2> type; 1665 }; 1666 1667 template<class A1, class A2, class A3> struct list_av_3 1668 { 1669 typedef typename add_value<A1>::type B1; 1670 typedef typename add_value<A2>::type B2; 1671 typedef typename add_value<A3>::type B3; 1672 typedef list3<B1, B2, B3> type; 1673 }; 1674 1675 template<class A1, class A2, class A3, class A4> struct list_av_4 1676 { 1677 typedef typename add_value<A1>::type B1; 1678 typedef typename add_value<A2>::type B2; 1679 typedef typename add_value<A3>::type B3; 1680 typedef typename add_value<A4>::type B4; 1681 typedef list4<B1, B2, B3, B4> type; 1682 }; 1683 1684 template<class A1, class A2, class A3, class A4, class A5> struct list_av_5 1685 { 1686 typedef typename add_value<A1>::type B1; 1687 typedef typename add_value<A2>::type B2; 1688 typedef typename add_value<A3>::type B3; 1689 typedef typename add_value<A4>::type B4; 1690 typedef typename add_value<A5>::type B5; 1691 typedef list5<B1, B2, B3, B4, B5> type; 1692 }; 1693 1694 template<class A1, class A2, class A3, class A4, class A5, class A6> struct list_av_6 1695 { 1696 typedef typename add_value<A1>::type B1; 1697 typedef typename add_value<A2>::type B2; 1698 typedef typename add_value<A3>::type B3; 1699 typedef typename add_value<A4>::type B4; 1700 typedef typename add_value<A5>::type B5; 1701 typedef typename add_value<A6>::type B6; 1702 typedef list6<B1, B2, B3, B4, B5, B6> type; 1703 }; 1704 1705 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct list_av_7 1706 { 1707 typedef typename add_value<A1>::type B1; 1708 typedef typename add_value<A2>::type B2; 1709 typedef typename add_value<A3>::type B3; 1710 typedef typename add_value<A4>::type B4; 1711 typedef typename add_value<A5>::type B5; 1712 typedef typename add_value<A6>::type B6; 1713 typedef typename add_value<A7>::type B7; 1714 typedef list7<B1, B2, B3, B4, B5, B6, B7> type; 1715 }; 1716 1717 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct list_av_8 1718 { 1719 typedef typename add_value<A1>::type B1; 1720 typedef typename add_value<A2>::type B2; 1721 typedef typename add_value<A3>::type B3; 1722 typedef typename add_value<A4>::type B4; 1723 typedef typename add_value<A5>::type B5; 1724 typedef typename add_value<A6>::type B6; 1725 typedef typename add_value<A7>::type B7; 1726 typedef typename add_value<A8>::type B8; 1727 typedef list8<B1, B2, B3, B4, B5, B6, B7, B8> type; 1728 }; 1729 1730 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> struct list_av_9 1731 { 1732 typedef typename add_value<A1>::type B1; 1733 typedef typename add_value<A2>::type B2; 1734 typedef typename add_value<A3>::type B3; 1735 typedef typename add_value<A4>::type B4; 1736 typedef typename add_value<A5>::type B5; 1737 typedef typename add_value<A6>::type B6; 1738 typedef typename add_value<A7>::type B7; 1739 typedef typename add_value<A8>::type B8; 1740 typedef typename add_value<A9>::type B9; 1741 typedef list9<B1, B2, B3, B4, B5, B6, B7, B8, B9> type; 1742 }; 1743 1744 // operator! 1745 1746 struct logical_not 1747 { 1748 template<class V> bool operator()(V const & v) const { return !v; } 1749 }; 1750 1751 template<class R, class F, class L> 1752 bind_t< bool, logical_not, list1< bind_t<R, F, L> > > 1753 operator! (bind_t<R, F, L> const & f) 1754 { 1755 typedef list1< bind_t<R, F, L> > list_type; 1756 return bind_t<bool, logical_not, list_type> ( logical_not(), list_type(f) ); 1757 } 1758 1759 // relational operators 1760 1761 #define BOOST_BIND_OPERATOR( op, name ) \ 1762 \ 1763 struct name \ 1764 { \ 1765 template<class V, class W> bool operator()(V const & v, W const & w) const { return v op w; } \ 1766 }; \ 1767 \ 1768 template<class R, class F, class L, class A2> \ 1769 bind_t< bool, name, list2< bind_t<R, F, L>, typename add_value<A2>::type > > \ 1770 operator op (bind_t<R, F, L> const & f, A2 a2) \ 1771 { \ 1772 typedef typename add_value<A2>::type B2; \ 1773 typedef list2< bind_t<R, F, L>, B2> list_type; \ 1774 return bind_t<bool, name, list_type> ( name(), list_type(f, a2) ); \ 1775 } 1776 1777 BOOST_BIND_OPERATOR( ==, equal ) 1778 BOOST_BIND_OPERATOR( !=, not_equal ) 1779 1780 BOOST_BIND_OPERATOR( <, less ) 1781 BOOST_BIND_OPERATOR( <=, less_equal ) 1782 1783 BOOST_BIND_OPERATOR( >, greater ) 1784 BOOST_BIND_OPERATOR( >=, greater_equal ) 1785 1786 BOOST_BIND_OPERATOR( &&, logical_and ) 1787 BOOST_BIND_OPERATOR( ||, logical_or ) 1788 1789 #undef BOOST_BIND_OPERATOR 1790 1791 #if defined(__GNUC__) && BOOST_WORKAROUND(__GNUC__, < 3) 1792 1793 // resolve ambiguity with rel_ops 1794 1795 #define BOOST_BIND_OPERATOR( op, name ) \ 1796 \ 1797 template<class R, class F, class L> \ 1798 bind_t< bool, name, list2< bind_t<R, F, L>, bind_t<R, F, L> > > \ 1799 operator op (bind_t<R, F, L> const & f, bind_t<R, F, L> const & g) \ 1800 { \ 1801 typedef list2< bind_t<R, F, L>, bind_t<R, F, L> > list_type; \ 1802 return bind_t<bool, name, list_type> ( name(), list_type(f, g) ); \ 1803 } 1804 1805 BOOST_BIND_OPERATOR( !=, not_equal ) 1806 BOOST_BIND_OPERATOR( <=, less_equal ) 1807 BOOST_BIND_OPERATOR( >, greater ) 1808 BOOST_BIND_OPERATOR( >=, greater_equal ) 1809 1810 #endif 1811 1812 // visit_each, ADL 1813 1814 #if !defined( BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP ) && !defined( __BORLANDC__ ) \ 1815 && !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3) 1816 1817 template<class V, class T> void visit_each( V & v, value<T> const & t, int ) 1818 { 1819 using boost::visit_each; 1820 BOOST_BIND_VISIT_EACH( v, t.get(), 0 ); 1821 } 1822 1823 template<class V, class R, class F, class L> void visit_each( V & v, bind_t<R, F, L> const & t, int ) 1824 { 1825 t.accept( v ); 1826 } 1827 1828 #endif 1829 1830 } // namespace _bi 1831 1832 // visit_each, no ADL 1833 1834 #if defined( BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP ) || defined( __BORLANDC__ ) \ 1835 || (defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3) 1836 1837 template<class V, class T> void visit_each( V & v, _bi::value<T> const & t, int ) 1838 { 1839 BOOST_BIND_VISIT_EACH( v, t.get(), 0 ); 1840 } 1841 1842 template<class V, class R, class F, class L> void visit_each( V & v, _bi::bind_t<R, F, L> const & t, int ) 1843 { 1844 t.accept( v ); 1845 } 1846 1847 #endif 1848 1849 // is_bind_expression 1850 1851 template< class T > struct is_bind_expression 1852 { 1853 enum _vt { value = 0 }; 1854 }; 1855 1856 #if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) 1857 1858 template< class R, class F, class L > struct is_bind_expression< _bi::bind_t< R, F, L > > 1859 { 1860 enum _vt { value = 1 }; 1861 }; 1862 1863 #endif 1864 1865 // bind 1866 1867 #ifndef BOOST_BIND 1868 #define BOOST_BIND bind 1869 #endif 1870 1871 // generic function objects 1872 1873 template<class R, class F> 1874 _bi::bind_t<R, F, _bi::list0> 1875 BOOST_BIND(F f) 1876 { 1877 typedef _bi::list0 list_type; 1878 return _bi::bind_t<R, F, list_type> (f, list_type()); 1879 } 1880 1881 template<class R, class F, class A1> 1882 _bi::bind_t<R, F, typename _bi::list_av_1<A1>::type> 1883 BOOST_BIND(F f, A1 a1) 1884 { 1885 typedef typename _bi::list_av_1<A1>::type list_type; 1886 return _bi::bind_t<R, F, list_type> (f, list_type(a1)); 1887 } 1888 1889 template<class R, class F, class A1, class A2> 1890 _bi::bind_t<R, F, typename _bi::list_av_2<A1, A2>::type> 1891 BOOST_BIND(F f, A1 a1, A2 a2) 1892 { 1893 typedef typename _bi::list_av_2<A1, A2>::type list_type; 1894 return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2)); 1895 } 1896 1897 template<class R, class F, class A1, class A2, class A3> 1898 _bi::bind_t<R, F, typename _bi::list_av_3<A1, A2, A3>::type> 1899 BOOST_BIND(F f, A1 a1, A2 a2, A3 a3) 1900 { 1901 typedef typename _bi::list_av_3<A1, A2, A3>::type list_type; 1902 return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3)); 1903 } 1904 1905 template<class R, class F, class A1, class A2, class A3, class A4> 1906 _bi::bind_t<R, F, typename _bi::list_av_4<A1, A2, A3, A4>::type> 1907 BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4) 1908 { 1909 typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type; 1910 return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4)); 1911 } 1912 1913 template<class R, class F, class A1, class A2, class A3, class A4, class A5> 1914 _bi::bind_t<R, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type> 1915 BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) 1916 { 1917 typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type; 1918 return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5)); 1919 } 1920 1921 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6> 1922 _bi::bind_t<R, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type> 1923 BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) 1924 { 1925 typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type; 1926 return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6)); 1927 } 1928 1929 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7> 1930 _bi::bind_t<R, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type> 1931 BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) 1932 { 1933 typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type; 1934 return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7)); 1935 } 1936 1937 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> 1938 _bi::bind_t<R, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type> 1939 BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) 1940 { 1941 typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type; 1942 return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8)); 1943 } 1944 1945 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> 1946 _bi::bind_t<R, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type> 1947 BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) 1948 { 1949 typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type; 1950 return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9)); 1951 } 1952 1953 // generic function objects, alternative syntax 1954 1955 template<class R, class F> 1956 _bi::bind_t<R, F, _bi::list0> 1957 BOOST_BIND(boost::type<R>, F f) 1958 { 1959 typedef _bi::list0 list_type; 1960 return _bi::bind_t<R, F, list_type> (f, list_type()); 1961 } 1962 1963 template<class R, class F, class A1> 1964 _bi::bind_t<R, F, typename _bi::list_av_1<A1>::type> 1965 BOOST_BIND(boost::type<R>, F f, A1 a1) 1966 { 1967 typedef typename _bi::list_av_1<A1>::type list_type; 1968 return _bi::bind_t<R, F, list_type> (f, list_type(a1)); 1969 } 1970 1971 template<class R, class F, class A1, class A2> 1972 _bi::bind_t<R, F, typename _bi::list_av_2<A1, A2>::type> 1973 BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2) 1974 { 1975 typedef typename _bi::list_av_2<A1, A2>::type list_type; 1976 return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2)); 1977 } 1978 1979 template<class R, class F, class A1, class A2, class A3> 1980 _bi::bind_t<R, F, typename _bi::list_av_3<A1, A2, A3>::type> 1981 BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3) 1982 { 1983 typedef typename _bi::list_av_3<A1, A2, A3>::type list_type; 1984 return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3)); 1985 } 1986 1987 template<class R, class F, class A1, class A2, class A3, class A4> 1988 _bi::bind_t<R, F, typename _bi::list_av_4<A1, A2, A3, A4>::type> 1989 BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4) 1990 { 1991 typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type; 1992 return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4)); 1993 } 1994 1995 template<class R, class F, class A1, class A2, class A3, class A4, class A5> 1996 _bi::bind_t<R, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type> 1997 BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) 1998 { 1999 typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type; 2000 return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5)); 2001 } 2002 2003 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6> 2004 _bi::bind_t<R, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type> 2005 BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) 2006 { 2007 typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type; 2008 return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6)); 2009 } 2010 2011 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7> 2012 _bi::bind_t<R, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type> 2013 BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) 2014 { 2015 typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type; 2016 return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7)); 2017 } 2018 2019 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> 2020 _bi::bind_t<R, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type> 2021 BOOST_BIND(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) 2022 { 2023 typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type; 2024 return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8)); 2025 } 2026 2027 template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> 2028 _bi::bind_t<R, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type> 2029 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) 2030 { 2031 typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type; 2032 return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9)); 2033 } 2034 2035 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) 2036 2037 // adaptable function objects 2038 2039 template<class F> 2040 _bi::bind_t<_bi::unspecified, F, _bi::list0> 2041 BOOST_BIND(F f) 2042 { 2043 typedef _bi::list0 list_type; 2044 return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type()); 2045 } 2046 2047 template<class F, class A1> 2048 _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_1<A1>::type> 2049 BOOST_BIND(F f, A1 a1) 2050 { 2051 typedef typename _bi::list_av_1<A1>::type list_type; 2052 return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type(a1)); 2053 } 2054 2055 template<class F, class A1, class A2> 2056 _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_2<A1, A2>::type> 2057 BOOST_BIND(F f, A1 a1, A2 a2) 2058 { 2059 typedef typename _bi::list_av_2<A1, A2>::type list_type; 2060 return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type(a1, a2)); 2061 } 2062 2063 template<class F, class A1, class A2, class A3> 2064 _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_3<A1, A2, A3>::type> 2065 BOOST_BIND(F f, A1 a1, A2 a2, A3 a3) 2066 { 2067 typedef typename _bi::list_av_3<A1, A2, A3>::type list_type; 2068 return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3)); 2069 } 2070 2071 template<class F, class A1, class A2, class A3, class A4> 2072 _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_4<A1, A2, A3, A4>::type> 2073 BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4) 2074 { 2075 typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type; 2076 return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4)); 2077 } 2078 2079 template<class F, class A1, class A2, class A3, class A4, class A5> 2080 _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type> 2081 BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) 2082 { 2083 typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type; 2084 return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5)); 2085 } 2086 2087 template<class F, class A1, class A2, class A3, class A4, class A5, class A6> 2088 _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type> 2089 BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) 2090 { 2091 typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type; 2092 return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6)); 2093 } 2094 2095 template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7> 2096 _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type> 2097 BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) 2098 { 2099 typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type; 2100 return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7)); 2101 } 2102 2103 template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> 2104 _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type> 2105 BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) 2106 { 2107 typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type; 2108 return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8)); 2109 } 2110 2111 template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> 2112 _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type> 2113 BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) 2114 { 2115 typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type; 2116 return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9)); 2117 } 2118 2119 #endif // !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) 2120 2121 // function pointers 2122 2123 #define BOOST_BIND_CC 2124 #define BOOST_BIND_ST 2125 #define BOOST_BIND_NOEXCEPT 2126 2127 #include <boost/bind/bind_cc.hpp> 2128 2129 # if defined( __cpp_noexcept_function_type ) || defined( _NOEXCEPT_TYPES_SUPPORTED ) 2130 # undef BOOST_BIND_NOEXCEPT 2131 # define BOOST_BIND_NOEXCEPT noexcept 2132 # include <boost/bind/bind_cc.hpp> 2133 # endif 2134 2135 #undef BOOST_BIND_CC 2136 #undef BOOST_BIND_ST 2137 #undef BOOST_BIND_NOEXCEPT 2138 2139 #ifdef BOOST_BIND_ENABLE_STDCALL 2140 2141 #define BOOST_BIND_CC __stdcall 2142 #define BOOST_BIND_ST 2143 #define BOOST_BIND_NOEXCEPT 2144 2145 #include <boost/bind/bind_cc.hpp> 2146 2147 #undef BOOST_BIND_CC 2148 #undef BOOST_BIND_ST 2149 #undef BOOST_BIND_NOEXCEPT 2150 2151 #endif 2152 2153 #ifdef BOOST_BIND_ENABLE_FASTCALL 2154 2155 #define BOOST_BIND_CC __fastcall 2156 #define BOOST_BIND_ST 2157 #define BOOST_BIND_NOEXCEPT 2158 2159 #include <boost/bind/bind_cc.hpp> 2160 2161 #undef BOOST_BIND_CC 2162 #undef BOOST_BIND_ST 2163 #undef BOOST_BIND_NOEXCEPT 2164 2165 #endif 2166 2167 #ifdef BOOST_BIND_ENABLE_PASCAL 2168 2169 #define BOOST_BIND_ST pascal 2170 #define BOOST_BIND_CC 2171 #define BOOST_BIND_NOEXCEPT 2172 2173 #include <boost/bind/bind_cc.hpp> 2174 2175 #undef BOOST_BIND_ST 2176 #undef BOOST_BIND_CC 2177 #undef BOOST_BIND_NOEXCEPT 2178 2179 #endif 2180 2181 // member function pointers 2182 2183 #define BOOST_BIND_MF_NAME(X) X 2184 #define BOOST_BIND_MF_CC 2185 #define BOOST_BIND_MF_NOEXCEPT 2186 2187 #include <boost/bind/bind_mf_cc.hpp> 2188 #include <boost/bind/bind_mf2_cc.hpp> 2189 2190 # if defined( __cpp_noexcept_function_type ) || defined( _NOEXCEPT_TYPES_SUPPORTED ) 2191 # undef BOOST_BIND_MF_NOEXCEPT 2192 # define BOOST_BIND_MF_NOEXCEPT noexcept 2193 # include <boost/bind/bind_mf_cc.hpp> 2194 # endif 2195 2196 #undef BOOST_BIND_MF_NAME 2197 #undef BOOST_BIND_MF_CC 2198 #undef BOOST_BIND_MF_NOEXCEPT 2199 2200 #ifdef BOOST_MEM_FN_ENABLE_CDECL 2201 2202 #define BOOST_BIND_MF_NAME(X) X##_cdecl 2203 #define BOOST_BIND_MF_CC __cdecl 2204 #define BOOST_BIND_MF_NOEXCEPT 2205 2206 #include <boost/bind/bind_mf_cc.hpp> 2207 #include <boost/bind/bind_mf2_cc.hpp> 2208 2209 #undef BOOST_BIND_MF_NAME 2210 #undef BOOST_BIND_MF_CC 2211 #undef BOOST_BIND_MF_NOEXCEPT 2212 2213 #endif 2214 2215 #ifdef BOOST_MEM_FN_ENABLE_STDCALL 2216 2217 #define BOOST_BIND_MF_NAME(X) X##_stdcall 2218 #define BOOST_BIND_MF_CC __stdcall 2219 #define BOOST_BIND_MF_NOEXCEPT 2220 2221 #include <boost/bind/bind_mf_cc.hpp> 2222 #include <boost/bind/bind_mf2_cc.hpp> 2223 2224 #undef BOOST_BIND_MF_NAME 2225 #undef BOOST_BIND_MF_CC 2226 #undef BOOST_BIND_MF_NOEXCEPT 2227 2228 #endif 2229 2230 #ifdef BOOST_MEM_FN_ENABLE_FASTCALL 2231 2232 #define BOOST_BIND_MF_NAME(X) X##_fastcall 2233 #define BOOST_BIND_MF_CC __fastcall 2234 #define BOOST_BIND_MF_NOEXCEPT 2235 2236 #include <boost/bind/bind_mf_cc.hpp> 2237 #include <boost/bind/bind_mf2_cc.hpp> 2238 2239 #undef BOOST_BIND_MF_NAME 2240 #undef BOOST_BIND_MF_CC 2241 #undef BOOST_BIND_MF_NOEXCEPT 2242 2243 #endif 2244 2245 // data member pointers 2246 2247 #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \ 2248 || ( defined(__BORLANDC__) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT( 0x620 ) ) ) 2249 2250 template<class R, class T, class A1> 2251 _bi::bind_t< R, _mfi::dm<R, T>, typename _bi::list_av_1<A1>::type > 2252 BOOST_BIND(R T::*f, A1 a1) 2253 { 2254 typedef _mfi::dm<R, T> F; 2255 typedef typename _bi::list_av_1<A1>::type list_type; 2256 return _bi::bind_t<R, F, list_type>( F(f), list_type(a1) ); 2257 } 2258 2259 #else 2260 2261 namespace _bi 2262 { 2263 2264 template< class Pm, int I > struct add_cref; 2265 2266 template< class M, class T > struct add_cref< M T::*, 0 > 2267 { 2268 typedef M type; 2269 }; 2270 2271 template< class M, class T > struct add_cref< M T::*, 1 > 2272 { 2273 #ifdef BOOST_MSVC 2274 #pragma warning(push) 2275 #pragma warning(disable:4180) 2276 #endif 2277 typedef M const & type; 2278 #ifdef BOOST_MSVC 2279 #pragma warning(pop) 2280 #endif 2281 }; 2282 2283 template< class R, class T > struct add_cref< R (T::*) (), 1 > 2284 { 2285 typedef void type; 2286 }; 2287 2288 #if !defined(__IBMCPP__) || __IBMCPP_FUNC_CV_TMPL_ARG_DEDUCTION 2289 2290 template< class R, class T > struct add_cref< R (T::*) () const, 1 > 2291 { 2292 typedef void type; 2293 }; 2294 2295 #if defined( __cpp_noexcept_function_type ) || defined( _NOEXCEPT_TYPES_SUPPORTED ) 2296 2297 template< class R, class T > struct add_cref< R (T::*) () const noexcept, 1 > 2298 { 2299 typedef void type; 2300 }; 2301 2302 #endif // __cpp_noexcept_function_type 2303 2304 #endif // __IBMCPP__ 2305 2306 template<class R> struct isref 2307 { 2308 enum value_type { value = 0 }; 2309 }; 2310 2311 template<class R> struct isref< R& > 2312 { 2313 enum value_type { value = 1 }; 2314 }; 2315 2316 template<class R> struct isref< R* > 2317 { 2318 enum value_type { value = 1 }; 2319 }; 2320 2321 template<class Pm, class A1> struct dm_result 2322 { 2323 typedef typename add_cref< Pm, 1 >::type type; 2324 }; 2325 2326 template<class Pm, class R, class F, class L> struct dm_result< Pm, bind_t<R, F, L> > 2327 { 2328 typedef typename bind_t<R, F, L>::result_type result_type; 2329 typedef typename add_cref< Pm, isref< result_type >::value >::type type; 2330 }; 2331 2332 } // namespace _bi 2333 2334 template< class A1, class M, class T > 2335 2336 _bi::bind_t< 2337 typename _bi::dm_result< M T::*, A1 >::type, 2338 _mfi::dm<M, T>, 2339 typename _bi::list_av_1<A1>::type 2340 > 2341 2342 BOOST_BIND( M T::*f, A1 a1 ) 2343 { 2344 typedef typename _bi::dm_result< M T::*, A1 >::type result_type; 2345 typedef _mfi::dm<M, T> F; 2346 typedef typename _bi::list_av_1<A1>::type list_type; 2347 return _bi::bind_t< result_type, F, list_type >( F( f ), list_type( a1 ) ); 2348 } 2349 2350 #endif 2351 2352 } // namespace boost 2353 2354 #ifndef BOOST_BIND_NO_PLACEHOLDERS 2355 2356 # include <boost/bind/placeholders.hpp> 2357 2358 #endif 2359 2360 #ifdef BOOST_MSVC 2361 # pragma warning(default: 4512) // assignment operator could not be generated 2362 # pragma warning(pop) 2363 #endif 2364 2365 #endif // #ifndef BOOST_BIND_BIND_HPP_INCLUDED 2366