1 // TR1 functional header -*- C++ -*- 2 3 // Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc. 4 // 5 // This file is part of the GNU ISO C++ Library. This library is free 6 // software; you can redistribute it and/or modify it under the 7 // terms of the GNU General Public License as published by the 8 // Free Software Foundation; either version 3, or (at your option) 9 // any later version. 10 11 // This library is distributed in the hope that it will be useful, 12 // but WITHOUT ANY WARRANTY; without even the implied warranty of 13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 // GNU General Public License for more details. 15 16 // Under Section 7 of GPL version 3, you are granted additional 17 // permissions described in the GCC Runtime Library Exception, version 18 // 3.1, as published by the Free Software Foundation. 19 20 // You should have received a copy of the GNU General Public License and 21 // a copy of the GCC Runtime Library Exception along with this program; 22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 23 // <http://www.gnu.org/licenses/>. 24 25 /** @file tr1_impl/functional 26 * This is an internal header file, included by other library headers. 27 * You should not attempt to use it directly. 28 */ 29 30 namespace std 31 { 32 _GLIBCXX_BEGIN_NAMESPACE_TR1 33 34 template<typename _MemberPointer> 35 class _Mem_fn; 36 37 /** 38 * Actual implementation of _Has_result_type, which uses SFINAE to 39 * determine if the type _Tp has a publicly-accessible member type 40 * result_type. 41 */ 42 template<typename _Tp> 43 class _Has_result_type_helper : __sfinae_types 44 { 45 template<typename _Up> 46 struct _Wrap_type 47 { }; 48 49 template<typename _Up> 50 static __one __test(_Wrap_type<typename _Up::result_type>*); 51 52 template<typename _Up> 53 static __two __test(...); 54 55 public: 56 static const bool value = sizeof(__test<_Tp>(0)) == 1; 57 }; 58 59 template<typename _Tp> 60 struct _Has_result_type 61 : integral_constant<bool, 62 _Has_result_type_helper<typename remove_cv<_Tp>::type>::value> 63 { }; 64 65 /** 66 * 67 */ 68 /// If we have found a result_type, extract it. 69 template<bool _Has_result_type, typename _Functor> 70 struct _Maybe_get_result_type 71 { }; 72 73 template<typename _Functor> 74 struct _Maybe_get_result_type<true, _Functor> 75 { 76 typedef typename _Functor::result_type result_type; 77 }; 78 79 /** 80 * Base class for any function object that has a weak result type, as 81 * defined in 3.3/3 of TR1. 82 */ 83 template<typename _Functor> 84 struct _Weak_result_type_impl 85 : _Maybe_get_result_type<_Has_result_type<_Functor>::value, _Functor> 86 { 87 }; 88 89 /// Retrieve the result type for a function type. 90 template<typename _Res, typename... _ArgTypes> 91 struct _Weak_result_type_impl<_Res(_ArgTypes...)> 92 { 93 typedef _Res result_type; 94 }; 95 96 /// Retrieve the result type for a function reference. 97 template<typename _Res, typename... _ArgTypes> 98 struct _Weak_result_type_impl<_Res(&)(_ArgTypes...)> 99 { 100 typedef _Res result_type; 101 }; 102 103 /// Retrieve the result type for a function pointer. 104 template<typename _Res, typename... _ArgTypes> 105 struct _Weak_result_type_impl<_Res(*)(_ArgTypes...)> 106 { 107 typedef _Res result_type; 108 }; 109 110 /// Retrieve result type for a member function pointer. 111 template<typename _Res, typename _Class, typename... _ArgTypes> 112 struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)> 113 { 114 typedef _Res result_type; 115 }; 116 117 /// Retrieve result type for a const member function pointer. 118 template<typename _Res, typename _Class, typename... _ArgTypes> 119 struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) const> 120 { 121 typedef _Res result_type; 122 }; 123 124 /// Retrieve result type for a volatile member function pointer. 125 template<typename _Res, typename _Class, typename... _ArgTypes> 126 struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) volatile> 127 { 128 typedef _Res result_type; 129 }; 130 131 /// Retrieve result type for a const volatile member function pointer. 132 template<typename _Res, typename _Class, typename... _ArgTypes> 133 struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)const volatile> 134 { 135 typedef _Res result_type; 136 }; 137 138 /** 139 * Strip top-level cv-qualifiers from the function object and let 140 * _Weak_result_type_impl perform the real work. 141 */ 142 template<typename _Functor> 143 struct _Weak_result_type 144 : _Weak_result_type_impl<typename remove_cv<_Functor>::type> 145 { 146 }; 147 148 template<typename _Signature> 149 class result_of; 150 151 /** 152 * Actual implementation of result_of. When _Has_result_type is 153 * true, gets its result from _Weak_result_type. Otherwise, uses 154 * the function object's member template result to extract the 155 * result type. 156 */ 157 template<bool _Has_result_type, typename _Signature> 158 struct _Result_of_impl; 159 160 // Handle member data pointers using _Mem_fn's logic 161 template<typename _Res, typename _Class, typename _T1> 162 struct _Result_of_impl<false, _Res _Class::*(_T1)> 163 { 164 typedef typename _Mem_fn<_Res _Class::*> 165 ::template _Result_type<_T1>::type type; 166 }; 167 168 /** 169 * Determine whether we can determine a result type from @c Functor 170 * alone. 171 */ 172 template<typename _Functor, typename... _ArgTypes> 173 class result_of<_Functor(_ArgTypes...)> 174 : public _Result_of_impl< 175 _Has_result_type<_Weak_result_type<_Functor> >::value, 176 _Functor(_ArgTypes...)> 177 { 178 }; 179 180 /// We already know the result type for @c Functor; use it. 181 template<typename _Functor, typename... _ArgTypes> 182 struct _Result_of_impl<true, _Functor(_ArgTypes...)> 183 { 184 typedef typename _Weak_result_type<_Functor>::result_type type; 185 }; 186 187 /** 188 * We need to compute the result type for this invocation the hard 189 * way. 190 */ 191 template<typename _Functor, typename... _ArgTypes> 192 struct _Result_of_impl<false, _Functor(_ArgTypes...)> 193 { 194 typedef typename _Functor 195 ::template result<_Functor(_ArgTypes...)>::type type; 196 }; 197 198 /** 199 * It is unsafe to access ::result when there are zero arguments, so we 200 * return @c void instead. 201 */ 202 template<typename _Functor> 203 struct _Result_of_impl<false, _Functor()> 204 { 205 typedef void type; 206 }; 207 208 /// Determines if the type _Tp derives from unary_function. 209 template<typename _Tp> 210 struct _Derives_from_unary_function : __sfinae_types 211 { 212 private: 213 template<typename _T1, typename _Res> 214 static __one __test(const volatile unary_function<_T1, _Res>*); 215 216 // It's tempting to change "..." to const volatile void*, but 217 // that fails when _Tp is a function type. 218 static __two __test(...); 219 220 public: 221 static const bool value = sizeof(__test((_Tp*)0)) == 1; 222 }; 223 224 /// Determines if the type _Tp derives from binary_function. 225 template<typename _Tp> 226 struct _Derives_from_binary_function : __sfinae_types 227 { 228 private: 229 template<typename _T1, typename _T2, typename _Res> 230 static __one __test(const volatile binary_function<_T1, _T2, _Res>*); 231 232 // It's tempting to change "..." to const volatile void*, but 233 // that fails when _Tp is a function type. 234 static __two __test(...); 235 236 public: 237 static const bool value = sizeof(__test((_Tp*)0)) == 1; 238 }; 239 240 /// Turns a function type into a function pointer type 241 template<typename _Tp, bool _IsFunctionType = is_function<_Tp>::value> 242 struct _Function_to_function_pointer 243 { 244 typedef _Tp type; 245 }; 246 247 template<typename _Tp> 248 struct _Function_to_function_pointer<_Tp, true> 249 { 250 typedef _Tp* type; 251 }; 252 253 /** 254 * Invoke a function object, which may be either a member pointer or a 255 * function object. The first parameter will tell which. 256 */ 257 template<typename _Functor, typename... _Args> 258 inline 259 typename __gnu_cxx::__enable_if< 260 (!is_member_pointer<_Functor>::value 261 && !is_function<_Functor>::value 262 && !is_function<typename remove_pointer<_Functor>::type>::value), 263 typename result_of<_Functor(_Args...)>::type 264 >::__type 265 __invoke(_Functor& __f, _Args&... __args) 266 { 267 return __f(__args...); 268 } 269 270 template<typename _Functor, typename... _Args> 271 inline 272 typename __gnu_cxx::__enable_if< 273 (is_member_pointer<_Functor>::value 274 && !is_function<_Functor>::value 275 && !is_function<typename remove_pointer<_Functor>::type>::value), 276 typename result_of<_Functor(_Args...)>::type 277 >::__type 278 __invoke(_Functor& __f, _Args&... __args) 279 { 280 return mem_fn(__f)(__args...); 281 } 282 283 // To pick up function references (that will become function pointers) 284 template<typename _Functor, typename... _Args> 285 inline 286 typename __gnu_cxx::__enable_if< 287 (is_pointer<_Functor>::value 288 && is_function<typename remove_pointer<_Functor>::type>::value), 289 typename result_of<_Functor(_Args...)>::type 290 >::__type 291 __invoke(_Functor __f, _Args&... __args) 292 { 293 return __f(__args...); 294 } 295 296 /** 297 * Knowing which of unary_function and binary_function _Tp derives 298 * from, derives from the same and ensures that reference_wrapper 299 * will have a weak result type. See cases below. 300 */ 301 template<bool _Unary, bool _Binary, typename _Tp> 302 struct _Reference_wrapper_base_impl; 303 304 // Not a unary_function or binary_function, so try a weak result type. 305 template<typename _Tp> 306 struct _Reference_wrapper_base_impl<false, false, _Tp> 307 : _Weak_result_type<_Tp> 308 { }; 309 310 // unary_function but not binary_function 311 template<typename _Tp> 312 struct _Reference_wrapper_base_impl<true, false, _Tp> 313 : unary_function<typename _Tp::argument_type, 314 typename _Tp::result_type> 315 { }; 316 317 // binary_function but not unary_function 318 template<typename _Tp> 319 struct _Reference_wrapper_base_impl<false, true, _Tp> 320 : binary_function<typename _Tp::first_argument_type, 321 typename _Tp::second_argument_type, 322 typename _Tp::result_type> 323 { }; 324 325 // Both unary_function and binary_function. Import result_type to 326 // avoid conflicts. 327 template<typename _Tp> 328 struct _Reference_wrapper_base_impl<true, true, _Tp> 329 : unary_function<typename _Tp::argument_type, 330 typename _Tp::result_type>, 331 binary_function<typename _Tp::first_argument_type, 332 typename _Tp::second_argument_type, 333 typename _Tp::result_type> 334 { 335 typedef typename _Tp::result_type result_type; 336 }; 337 338 /** 339 * Derives from unary_function or binary_function when it 340 * can. Specializations handle all of the easy cases. The primary 341 * template determines what to do with a class type, which may 342 * derive from both unary_function and binary_function. 343 */ 344 template<typename _Tp> 345 struct _Reference_wrapper_base 346 : _Reference_wrapper_base_impl< 347 _Derives_from_unary_function<_Tp>::value, 348 _Derives_from_binary_function<_Tp>::value, 349 _Tp> 350 { }; 351 352 // - a function type (unary) 353 template<typename _Res, typename _T1> 354 struct _Reference_wrapper_base<_Res(_T1)> 355 : unary_function<_T1, _Res> 356 { }; 357 358 // - a function type (binary) 359 template<typename _Res, typename _T1, typename _T2> 360 struct _Reference_wrapper_base<_Res(_T1, _T2)> 361 : binary_function<_T1, _T2, _Res> 362 { }; 363 364 // - a function pointer type (unary) 365 template<typename _Res, typename _T1> 366 struct _Reference_wrapper_base<_Res(*)(_T1)> 367 : unary_function<_T1, _Res> 368 { }; 369 370 // - a function pointer type (binary) 371 template<typename _Res, typename _T1, typename _T2> 372 struct _Reference_wrapper_base<_Res(*)(_T1, _T2)> 373 : binary_function<_T1, _T2, _Res> 374 { }; 375 376 // - a pointer to member function type (unary, no qualifiers) 377 template<typename _Res, typename _T1> 378 struct _Reference_wrapper_base<_Res (_T1::*)()> 379 : unary_function<_T1*, _Res> 380 { }; 381 382 // - a pointer to member function type (binary, no qualifiers) 383 template<typename _Res, typename _T1, typename _T2> 384 struct _Reference_wrapper_base<_Res (_T1::*)(_T2)> 385 : binary_function<_T1*, _T2, _Res> 386 { }; 387 388 // - a pointer to member function type (unary, const) 389 template<typename _Res, typename _T1> 390 struct _Reference_wrapper_base<_Res (_T1::*)() const> 391 : unary_function<const _T1*, _Res> 392 { }; 393 394 // - a pointer to member function type (binary, const) 395 template<typename _Res, typename _T1, typename _T2> 396 struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const> 397 : binary_function<const _T1*, _T2, _Res> 398 { }; 399 400 // - a pointer to member function type (unary, volatile) 401 template<typename _Res, typename _T1> 402 struct _Reference_wrapper_base<_Res (_T1::*)() volatile> 403 : unary_function<volatile _T1*, _Res> 404 { }; 405 406 // - a pointer to member function type (binary, volatile) 407 template<typename _Res, typename _T1, typename _T2> 408 struct _Reference_wrapper_base<_Res (_T1::*)(_T2) volatile> 409 : binary_function<volatile _T1*, _T2, _Res> 410 { }; 411 412 // - a pointer to member function type (unary, const volatile) 413 template<typename _Res, typename _T1> 414 struct _Reference_wrapper_base<_Res (_T1::*)() const volatile> 415 : unary_function<const volatile _T1*, _Res> 416 { }; 417 418 // - a pointer to member function type (binary, const volatile) 419 template<typename _Res, typename _T1, typename _T2> 420 struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const volatile> 421 : binary_function<const volatile _T1*, _T2, _Res> 422 { }; 423 424 /// reference_wrapper 425 template<typename _Tp> 426 class reference_wrapper 427 : public _Reference_wrapper_base<typename remove_cv<_Tp>::type> 428 { 429 // If _Tp is a function type, we can't form result_of<_Tp(...)>, 430 // so turn it into a function pointer type. 431 typedef typename _Function_to_function_pointer<_Tp>::type 432 _M_func_type; 433 434 _Tp* _M_data; 435 public: 436 typedef _Tp type; 437 438 explicit 439 reference_wrapper(_Tp& __indata): _M_data(&__indata) 440 { } 441 442 reference_wrapper(const reference_wrapper<_Tp>& __inref): 443 _M_data(__inref._M_data) 444 { } 445 446 reference_wrapper& 447 operator=(const reference_wrapper<_Tp>& __inref) 448 { 449 _M_data = __inref._M_data; 450 return *this; 451 } 452 453 operator _Tp&() const 454 { return this->get(); } 455 456 _Tp& 457 get() const 458 { return *_M_data; } 459 460 template<typename... _Args> 461 typename result_of<_M_func_type(_Args...)>::type 462 operator()(_Args&... __args) const 463 { 464 return __invoke(get(), __args...); 465 } 466 }; 467 468 469 // Denotes a reference should be taken to a variable. 470 template<typename _Tp> 471 inline reference_wrapper<_Tp> 472 ref(_Tp& __t) 473 { return reference_wrapper<_Tp>(__t); } 474 475 // Denotes a const reference should be taken to a variable. 476 template<typename _Tp> 477 inline reference_wrapper<const _Tp> 478 cref(const _Tp& __t) 479 { return reference_wrapper<const _Tp>(__t); } 480 481 template<typename _Tp> 482 inline reference_wrapper<_Tp> 483 ref(reference_wrapper<_Tp> __t) 484 { return ref(__t.get()); } 485 486 template<typename _Tp> 487 inline reference_wrapper<const _Tp> 488 cref(reference_wrapper<_Tp> __t) 489 { return cref(__t.get()); } 490 491 template<typename _Tp, bool> 492 struct _Mem_fn_const_or_non 493 { 494 typedef const _Tp& type; 495 }; 496 497 template<typename _Tp> 498 struct _Mem_fn_const_or_non<_Tp, false> 499 { 500 typedef _Tp& type; 501 }; 502 503 /** 504 * Derives from @c unary_function or @c binary_function, or perhaps 505 * nothing, depending on the number of arguments provided. The 506 * primary template is the basis case, which derives nothing. 507 */ 508 template<typename _Res, typename... _ArgTypes> 509 struct _Maybe_unary_or_binary_function { }; 510 511 /// Derives from @c unary_function, as appropriate. 512 template<typename _Res, typename _T1> 513 struct _Maybe_unary_or_binary_function<_Res, _T1> 514 : std::unary_function<_T1, _Res> { }; 515 516 /// Derives from @c binary_function, as appropriate. 517 template<typename _Res, typename _T1, typename _T2> 518 struct _Maybe_unary_or_binary_function<_Res, _T1, _T2> 519 : std::binary_function<_T1, _T2, _Res> { }; 520 521 /// Implementation of @c mem_fn for member function pointers. 522 template<typename _Res, typename _Class, typename... _ArgTypes> 523 class _Mem_fn<_Res (_Class::*)(_ArgTypes...)> 524 : public _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...> 525 { 526 typedef _Res (_Class::*_Functor)(_ArgTypes...); 527 528 template<typename _Tp> 529 _Res 530 _M_call(_Tp& __object, const volatile _Class *, 531 _ArgTypes... __args) const 532 { return (__object.*__pmf)(__args...); } 533 534 template<typename _Tp> 535 _Res 536 _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const 537 { return ((*__ptr).*__pmf)(__args...); } 538 539 public: 540 typedef _Res result_type; 541 542 explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { } 543 544 // Handle objects 545 _Res 546 operator()(_Class& __object, _ArgTypes... __args) const 547 { return (__object.*__pmf)(__args...); } 548 549 // Handle pointers 550 _Res 551 operator()(_Class* __object, _ArgTypes... __args) const 552 { return (__object->*__pmf)(__args...); } 553 554 // Handle smart pointers, references and pointers to derived 555 template<typename _Tp> 556 _Res 557 operator()(_Tp& __object, _ArgTypes... __args) const 558 { return _M_call(__object, &__object, __args...); } 559 560 private: 561 _Functor __pmf; 562 }; 563 564 /// Implementation of @c mem_fn for const member function pointers. 565 template<typename _Res, typename _Class, typename... _ArgTypes> 566 class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const> 567 : public _Maybe_unary_or_binary_function<_Res, const _Class*, 568 _ArgTypes...> 569 { 570 typedef _Res (_Class::*_Functor)(_ArgTypes...) const; 571 572 template<typename _Tp> 573 _Res 574 _M_call(_Tp& __object, const volatile _Class *, 575 _ArgTypes... __args) const 576 { return (__object.*__pmf)(__args...); } 577 578 template<typename _Tp> 579 _Res 580 _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const 581 { return ((*__ptr).*__pmf)(__args...); } 582 583 public: 584 typedef _Res result_type; 585 586 explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { } 587 588 // Handle objects 589 _Res 590 operator()(const _Class& __object, _ArgTypes... __args) const 591 { return (__object.*__pmf)(__args...); } 592 593 // Handle pointers 594 _Res 595 operator()(const _Class* __object, _ArgTypes... __args) const 596 { return (__object->*__pmf)(__args...); } 597 598 // Handle smart pointers, references and pointers to derived 599 template<typename _Tp> 600 _Res operator()(_Tp& __object, _ArgTypes... __args) const 601 { return _M_call(__object, &__object, __args...); } 602 603 private: 604 _Functor __pmf; 605 }; 606 607 /// Implementation of @c mem_fn for volatile member function pointers. 608 template<typename _Res, typename _Class, typename... _ArgTypes> 609 class _Mem_fn<_Res (_Class::*)(_ArgTypes...) volatile> 610 : public _Maybe_unary_or_binary_function<_Res, volatile _Class*, 611 _ArgTypes...> 612 { 613 typedef _Res (_Class::*_Functor)(_ArgTypes...) volatile; 614 615 template<typename _Tp> 616 _Res 617 _M_call(_Tp& __object, const volatile _Class *, 618 _ArgTypes... __args) const 619 { return (__object.*__pmf)(__args...); } 620 621 template<typename _Tp> 622 _Res 623 _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const 624 { return ((*__ptr).*__pmf)(__args...); } 625 626 public: 627 typedef _Res result_type; 628 629 explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { } 630 631 // Handle objects 632 _Res 633 operator()(volatile _Class& __object, _ArgTypes... __args) const 634 { return (__object.*__pmf)(__args...); } 635 636 // Handle pointers 637 _Res 638 operator()(volatile _Class* __object, _ArgTypes... __args) const 639 { return (__object->*__pmf)(__args...); } 640 641 // Handle smart pointers, references and pointers to derived 642 template<typename _Tp> 643 _Res 644 operator()(_Tp& __object, _ArgTypes... __args) const 645 { return _M_call(__object, &__object, __args...); } 646 647 private: 648 _Functor __pmf; 649 }; 650 651 /// Implementation of @c mem_fn for const volatile member function pointers. 652 template<typename _Res, typename _Class, typename... _ArgTypes> 653 class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const volatile> 654 : public _Maybe_unary_or_binary_function<_Res, const volatile _Class*, 655 _ArgTypes...> 656 { 657 typedef _Res (_Class::*_Functor)(_ArgTypes...) const volatile; 658 659 template<typename _Tp> 660 _Res 661 _M_call(_Tp& __object, const volatile _Class *, 662 _ArgTypes... __args) const 663 { return (__object.*__pmf)(__args...); } 664 665 template<typename _Tp> 666 _Res 667 _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const 668 { return ((*__ptr).*__pmf)(__args...); } 669 670 public: 671 typedef _Res result_type; 672 673 explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { } 674 675 // Handle objects 676 _Res 677 operator()(const volatile _Class& __object, _ArgTypes... __args) const 678 { return (__object.*__pmf)(__args...); } 679 680 // Handle pointers 681 _Res 682 operator()(const volatile _Class* __object, _ArgTypes... __args) const 683 { return (__object->*__pmf)(__args...); } 684 685 // Handle smart pointers, references and pointers to derived 686 template<typename _Tp> 687 _Res operator()(_Tp& __object, _ArgTypes... __args) const 688 { return _M_call(__object, &__object, __args...); } 689 690 private: 691 _Functor __pmf; 692 }; 693 694 695 template<typename _Res, typename _Class> 696 class _Mem_fn<_Res _Class::*> 697 { 698 // This bit of genius is due to Peter Dimov, improved slightly by 699 // Douglas Gregor. 700 template<typename _Tp> 701 _Res& 702 _M_call(_Tp& __object, _Class *) const 703 { return __object.*__pm; } 704 705 template<typename _Tp, typename _Up> 706 _Res& 707 _M_call(_Tp& __object, _Up * const *) const 708 { return (*__object).*__pm; } 709 710 template<typename _Tp, typename _Up> 711 const _Res& 712 _M_call(_Tp& __object, const _Up * const *) const 713 { return (*__object).*__pm; } 714 715 template<typename _Tp> 716 const _Res& 717 _M_call(_Tp& __object, const _Class *) const 718 { return __object.*__pm; } 719 720 template<typename _Tp> 721 const _Res& 722 _M_call(_Tp& __ptr, const volatile void*) const 723 { return (*__ptr).*__pm; } 724 725 template<typename _Tp> static _Tp& __get_ref(); 726 727 template<typename _Tp> 728 static __sfinae_types::__one __check_const(_Tp&, _Class*); 729 template<typename _Tp, typename _Up> 730 static __sfinae_types::__one __check_const(_Tp&, _Up * const *); 731 template<typename _Tp, typename _Up> 732 static __sfinae_types::__two __check_const(_Tp&, const _Up * const *); 733 template<typename _Tp> 734 static __sfinae_types::__two __check_const(_Tp&, const _Class*); 735 template<typename _Tp> 736 static __sfinae_types::__two __check_const(_Tp&, const volatile void*); 737 738 public: 739 template<typename _Tp> 740 struct _Result_type 741 : _Mem_fn_const_or_non<_Res, 742 (sizeof(__sfinae_types::__two) 743 == sizeof(__check_const<_Tp>(__get_ref<_Tp>(), (_Tp*)0)))> 744 { }; 745 746 template<typename _Signature> 747 struct result; 748 749 template<typename _CVMem, typename _Tp> 750 struct result<_CVMem(_Tp)> 751 : public _Result_type<_Tp> { }; 752 753 template<typename _CVMem, typename _Tp> 754 struct result<_CVMem(_Tp&)> 755 : public _Result_type<_Tp> { }; 756 757 explicit 758 _Mem_fn(_Res _Class::*__pm) : __pm(__pm) { } 759 760 // Handle objects 761 _Res& 762 operator()(_Class& __object) const 763 { return __object.*__pm; } 764 765 const _Res& 766 operator()(const _Class& __object) const 767 { return __object.*__pm; } 768 769 // Handle pointers 770 _Res& 771 operator()(_Class* __object) const 772 { return __object->*__pm; } 773 774 const _Res& 775 operator()(const _Class* __object) const 776 { return __object->*__pm; } 777 778 // Handle smart pointers and derived 779 template<typename _Tp> 780 typename _Result_type<_Tp>::type 781 operator()(_Tp& __unknown) const 782 { return _M_call(__unknown, &__unknown); } 783 784 private: 785 _Res _Class::*__pm; 786 }; 787 788 /** 789 * @brief Returns a function object that forwards to the member 790 * pointer @a pm. 791 */ 792 template<typename _Tp, typename _Class> 793 inline _Mem_fn<_Tp _Class::*> 794 mem_fn(_Tp _Class::* __pm) 795 { 796 return _Mem_fn<_Tp _Class::*>(__pm); 797 } 798 799 /** 800 * @brief Determines if the given type _Tp is a function object 801 * should be treated as a subexpression when evaluating calls to 802 * function objects returned by bind(). [TR1 3.6.1] 803 */ 804 template<typename _Tp> 805 struct is_bind_expression 806 { static const bool value = false; }; 807 808 template<typename _Tp> 809 const bool is_bind_expression<_Tp>::value; 810 811 /** 812 * @brief Determines if the given type _Tp is a placeholder in a 813 * bind() expression and, if so, which placeholder it is. [TR1 3.6.2] 814 */ 815 template<typename _Tp> 816 struct is_placeholder 817 { static const int value = 0; }; 818 819 template<typename _Tp> 820 const int is_placeholder<_Tp>::value; 821 822 /// The type of placeholder objects defined by libstdc++. 823 template<int _Num> struct _Placeholder { }; 824 825 /** @namespace std::placeholders 826 * @brief ISO C++ 0x entities sub namespace for functional. 827 * 828 * Define a large number of placeholders. There is no way to 829 * simplify this with variadic templates, because we're introducing 830 * unique names for each. 831 */ 832 namespace placeholders 833 { 834 namespace 835 { 836 _Placeholder<1> _1; 837 _Placeholder<2> _2; 838 _Placeholder<3> _3; 839 _Placeholder<4> _4; 840 _Placeholder<5> _5; 841 _Placeholder<6> _6; 842 _Placeholder<7> _7; 843 _Placeholder<8> _8; 844 _Placeholder<9> _9; 845 _Placeholder<10> _10; 846 _Placeholder<11> _11; 847 _Placeholder<12> _12; 848 _Placeholder<13> _13; 849 _Placeholder<14> _14; 850 _Placeholder<15> _15; 851 _Placeholder<16> _16; 852 _Placeholder<17> _17; 853 _Placeholder<18> _18; 854 _Placeholder<19> _19; 855 _Placeholder<20> _20; 856 _Placeholder<21> _21; 857 _Placeholder<22> _22; 858 _Placeholder<23> _23; 859 _Placeholder<24> _24; 860 _Placeholder<25> _25; 861 _Placeholder<26> _26; 862 _Placeholder<27> _27; 863 _Placeholder<28> _28; 864 _Placeholder<29> _29; 865 } 866 } 867 868 /** 869 * Partial specialization of is_placeholder that provides the placeholder 870 * number for the placeholder objects defined by libstdc++. 871 */ 872 template<int _Num> 873 struct is_placeholder<_Placeholder<_Num> > 874 { static const int value = _Num; }; 875 876 template<int _Num> 877 const int is_placeholder<_Placeholder<_Num> >::value; 878 879 /** 880 * Stores a tuple of indices. Used by bind() to extract the elements 881 * in a tuple. 882 */ 883 template<int... _Indexes> 884 struct _Index_tuple { }; 885 886 /// Builds an _Index_tuple<0, 1, 2, ..., _Num-1>. 887 template<std::size_t _Num, typename _Tuple = _Index_tuple<> > 888 struct _Build_index_tuple; 889 890 template<std::size_t _Num, int... _Indexes> 891 struct _Build_index_tuple<_Num, _Index_tuple<_Indexes...> > 892 : _Build_index_tuple<_Num - 1, 893 _Index_tuple<_Indexes..., sizeof...(_Indexes)> > 894 { 895 }; 896 897 template<int... _Indexes> 898 struct _Build_index_tuple<0, _Index_tuple<_Indexes...> > 899 { 900 typedef _Index_tuple<_Indexes...> __type; 901 }; 902 903 /** 904 * Used by _Safe_tuple_element to indicate that there is no tuple 905 * element at this position. 906 */ 907 struct _No_tuple_element; 908 909 /** 910 * Implementation helper for _Safe_tuple_element. This primary 911 * template handles the case where it is safe to use @c 912 * tuple_element. 913 */ 914 template<int __i, typename _Tuple, bool _IsSafe> 915 struct _Safe_tuple_element_impl 916 : tuple_element<__i, _Tuple> { }; 917 918 /** 919 * Implementation helper for _Safe_tuple_element. This partial 920 * specialization handles the case where it is not safe to use @c 921 * tuple_element. We just return @c _No_tuple_element. 922 */ 923 template<int __i, typename _Tuple> 924 struct _Safe_tuple_element_impl<__i, _Tuple, false> 925 { 926 typedef _No_tuple_element type; 927 }; 928 929 /** 930 * Like tuple_element, but returns @c _No_tuple_element when 931 * tuple_element would return an error. 932 */ 933 template<int __i, typename _Tuple> 934 struct _Safe_tuple_element 935 : _Safe_tuple_element_impl<__i, _Tuple, 936 (__i >= 0 && __i < tuple_size<_Tuple>::value)> 937 { 938 }; 939 940 /** 941 * Maps an argument to bind() into an actual argument to the bound 942 * function object [TR1 3.6.3/5]. Only the first parameter should 943 * be specified: the rest are used to determine among the various 944 * implementations. Note that, although this class is a function 945 * object, it isn't entirely normal because it takes only two 946 * parameters regardless of the number of parameters passed to the 947 * bind expression. The first parameter is the bound argument and 948 * the second parameter is a tuple containing references to the 949 * rest of the arguments. 950 */ 951 template<typename _Arg, 952 bool _IsBindExp = is_bind_expression<_Arg>::value, 953 bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)> 954 class _Mu; 955 956 /** 957 * If the argument is reference_wrapper<_Tp>, returns the 958 * underlying reference. [TR1 3.6.3/5 bullet 1] 959 */ 960 template<typename _Tp> 961 class _Mu<reference_wrapper<_Tp>, false, false> 962 { 963 public: 964 typedef _Tp& result_type; 965 966 /* Note: This won't actually work for const volatile 967 * reference_wrappers, because reference_wrapper::get() is const 968 * but not volatile-qualified. This might be a defect in the TR. 969 */ 970 template<typename _CVRef, typename _Tuple> 971 result_type 972 operator()(_CVRef& __arg, const _Tuple&) const volatile 973 { return __arg.get(); } 974 }; 975 976 /** 977 * If the argument is a bind expression, we invoke the underlying 978 * function object with the same cv-qualifiers as we are given and 979 * pass along all of our arguments (unwrapped). [TR1 3.6.3/5 bullet 2] 980 */ 981 template<typename _Arg> 982 class _Mu<_Arg, true, false> 983 { 984 public: 985 template<typename _Signature> class result; 986 987 // Determine the result type when we pass the arguments along. This 988 // involves passing along the cv-qualifiers placed on _Mu and 989 // unwrapping the argument bundle. 990 template<typename _CVMu, typename _CVArg, typename... _Args> 991 class result<_CVMu(_CVArg, tuple<_Args...>)> 992 : public result_of<_CVArg(_Args...)> { }; 993 994 template<typename _CVArg, typename... _Args> 995 typename result_of<_CVArg(_Args...)>::type 996 operator()(_CVArg& __arg, 997 const tuple<_Args...>& __tuple) const volatile 998 { 999 // Construct an index tuple and forward to __call 1000 typedef typename _Build_index_tuple<sizeof...(_Args)>::__type 1001 _Indexes; 1002 return this->__call(__arg, __tuple, _Indexes()); 1003 } 1004 1005 private: 1006 // Invokes the underlying function object __arg by unpacking all 1007 // of the arguments in the tuple. 1008 template<typename _CVArg, typename... _Args, int... _Indexes> 1009 typename result_of<_CVArg(_Args...)>::type 1010 __call(_CVArg& __arg, const tuple<_Args...>& __tuple, 1011 const _Index_tuple<_Indexes...>&) const volatile 1012 { 1013 return __arg(_GLIBCXX_TR1 get<_Indexes>(__tuple)...); 1014 } 1015 }; 1016 1017 /** 1018 * If the argument is a placeholder for the Nth argument, returns 1019 * a reference to the Nth argument to the bind function object. 1020 * [TR1 3.6.3/5 bullet 3] 1021 */ 1022 template<typename _Arg> 1023 class _Mu<_Arg, false, true> 1024 { 1025 public: 1026 template<typename _Signature> class result; 1027 1028 template<typename _CVMu, typename _CVArg, typename _Tuple> 1029 class result<_CVMu(_CVArg, _Tuple)> 1030 { 1031 // Add a reference, if it hasn't already been done for us. 1032 // This allows us to be a little bit sloppy in constructing 1033 // the tuple that we pass to result_of<...>. 1034 typedef typename _Safe_tuple_element<(is_placeholder<_Arg>::value 1035 - 1), _Tuple>::type 1036 __base_type; 1037 1038 public: 1039 #ifdef _GLIBCXX_INCLUDE_AS_CXX0X 1040 typedef typename add_lvalue_reference<__base_type>::type type; 1041 #else 1042 typedef typename add_reference<__base_type>::type type; 1043 #endif 1044 }; 1045 1046 template<typename _Tuple> 1047 typename result<_Mu(_Arg, _Tuple)>::type 1048 operator()(const volatile _Arg&, const _Tuple& __tuple) const volatile 1049 { 1050 return ::std::_GLIBCXX_TR1 get<(is_placeholder<_Arg>::value 1051 - 1)>(__tuple); 1052 } 1053 }; 1054 1055 /** 1056 * If the argument is just a value, returns a reference to that 1057 * value. The cv-qualifiers on the reference are the same as the 1058 * cv-qualifiers on the _Mu object. [TR1 3.6.3/5 bullet 4] 1059 */ 1060 template<typename _Arg> 1061 class _Mu<_Arg, false, false> 1062 { 1063 public: 1064 template<typename _Signature> struct result; 1065 1066 template<typename _CVMu, typename _CVArg, typename _Tuple> 1067 struct result<_CVMu(_CVArg, _Tuple)> 1068 { 1069 #ifdef _GLIBCXX_INCLUDE_AS_CXX0X 1070 typedef typename add_lvalue_reference<_CVArg>::type type; 1071 #else 1072 typedef typename add_reference<_CVArg>::type type; 1073 #endif 1074 }; 1075 1076 // Pick up the cv-qualifiers of the argument 1077 template<typename _CVArg, typename _Tuple> 1078 _CVArg& 1079 operator()(_CVArg& __arg, const _Tuple&) const volatile 1080 { return __arg; } 1081 }; 1082 1083 /** 1084 * Maps member pointers into instances of _Mem_fn but leaves all 1085 * other function objects untouched. Used by tr1::bind(). The 1086 * primary template handles the non--member-pointer case. 1087 */ 1088 template<typename _Tp> 1089 struct _Maybe_wrap_member_pointer 1090 { 1091 typedef _Tp type; 1092 1093 static const _Tp& 1094 __do_wrap(const _Tp& __x) 1095 { return __x; } 1096 }; 1097 1098 /** 1099 * Maps member pointers into instances of _Mem_fn but leaves all 1100 * other function objects untouched. Used by tr1::bind(). This 1101 * partial specialization handles the member pointer case. 1102 */ 1103 template<typename _Tp, typename _Class> 1104 struct _Maybe_wrap_member_pointer<_Tp _Class::*> 1105 { 1106 typedef _Mem_fn<_Tp _Class::*> type; 1107 1108 static type 1109 __do_wrap(_Tp _Class::* __pm) 1110 { return type(__pm); } 1111 }; 1112 1113 /// Type of the function object returned from bind(). 1114 template<typename _Signature> 1115 struct _Bind; 1116 1117 template<typename _Functor, typename... _Bound_args> 1118 class _Bind<_Functor(_Bound_args...)> 1119 : public _Weak_result_type<_Functor> 1120 { 1121 typedef _Bind __self_type; 1122 typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type 1123 _Bound_indexes; 1124 1125 _Functor _M_f; 1126 tuple<_Bound_args...> _M_bound_args; 1127 1128 // Call unqualified 1129 template<typename... _Args, int... _Indexes> 1130 typename result_of< 1131 _Functor(typename result_of<_Mu<_Bound_args> 1132 (_Bound_args, tuple<_Args...>)>::type...) 1133 >::type 1134 __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>) 1135 { 1136 return _M_f(_Mu<_Bound_args>() 1137 (_GLIBCXX_TR1 get<_Indexes>(_M_bound_args), __args)...); 1138 } 1139 1140 // Call as const 1141 template<typename... _Args, int... _Indexes> 1142 typename result_of< 1143 const _Functor(typename result_of<_Mu<_Bound_args> 1144 (const _Bound_args, tuple<_Args...>) 1145 >::type...)>::type 1146 __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>) const 1147 { 1148 return _M_f(_Mu<_Bound_args>() 1149 (_GLIBCXX_TR1 get<_Indexes>(_M_bound_args), __args)...); 1150 } 1151 1152 // Call as volatile 1153 template<typename... _Args, int... _Indexes> 1154 typename result_of< 1155 volatile _Functor(typename result_of<_Mu<_Bound_args> 1156 (volatile _Bound_args, tuple<_Args...>) 1157 >::type...)>::type 1158 __call(const tuple<_Args...>& __args, 1159 _Index_tuple<_Indexes...>) volatile 1160 { 1161 return _M_f(_Mu<_Bound_args>() 1162 (_GLIBCXX_TR1 get<_Indexes>(_M_bound_args), __args)...); 1163 } 1164 1165 // Call as const volatile 1166 template<typename... _Args, int... _Indexes> 1167 typename result_of< 1168 const volatile _Functor(typename result_of<_Mu<_Bound_args> 1169 (const volatile _Bound_args, 1170 tuple<_Args...>) 1171 >::type...)>::type 1172 __call(const tuple<_Args...>& __args, 1173 _Index_tuple<_Indexes...>) const volatile 1174 { 1175 return _M_f(_Mu<_Bound_args>() 1176 (_GLIBCXX_TR1 get<_Indexes>(_M_bound_args), __args)...); 1177 } 1178 1179 public: 1180 explicit _Bind(_Functor __f, _Bound_args... __bound_args) 1181 : _M_f(__f), _M_bound_args(__bound_args...) { } 1182 1183 // Call unqualified 1184 template<typename... _Args> 1185 typename result_of< 1186 _Functor(typename result_of<_Mu<_Bound_args> 1187 (_Bound_args, tuple<_Args...>)>::type...) 1188 >::type 1189 operator()(_Args&... __args) 1190 { 1191 return this->__call(_GLIBCXX_TR1 tie(__args...), _Bound_indexes()); 1192 } 1193 1194 // Call as const 1195 template<typename... _Args> 1196 typename result_of< 1197 const _Functor(typename result_of<_Mu<_Bound_args> 1198 (const _Bound_args, tuple<_Args...>)>::type...) 1199 >::type 1200 operator()(_Args&... __args) const 1201 { 1202 return this->__call(_GLIBCXX_TR1 tie(__args...), _Bound_indexes()); 1203 } 1204 1205 1206 // Call as volatile 1207 template<typename... _Args> 1208 typename result_of< 1209 volatile _Functor(typename result_of<_Mu<_Bound_args> 1210 (volatile _Bound_args, tuple<_Args...>)>::type...) 1211 >::type 1212 operator()(_Args&... __args) volatile 1213 { 1214 return this->__call(_GLIBCXX_TR1 tie(__args...), _Bound_indexes()); 1215 } 1216 1217 1218 // Call as const volatile 1219 template<typename... _Args> 1220 typename result_of< 1221 const volatile _Functor(typename result_of<_Mu<_Bound_args> 1222 (const volatile _Bound_args, 1223 tuple<_Args...>)>::type...) 1224 >::type 1225 operator()(_Args&... __args) const volatile 1226 { 1227 return this->__call(_GLIBCXX_TR1 tie(__args...), _Bound_indexes()); 1228 } 1229 }; 1230 1231 /// Type of the function object returned from bind<R>(). 1232 template<typename _Result, typename _Signature> 1233 struct _Bind_result; 1234 1235 template<typename _Result, typename _Functor, typename... _Bound_args> 1236 class _Bind_result<_Result, _Functor(_Bound_args...)> 1237 { 1238 typedef _Bind_result __self_type; 1239 typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type 1240 _Bound_indexes; 1241 1242 _Functor _M_f; 1243 tuple<_Bound_args...> _M_bound_args; 1244 1245 // Call unqualified 1246 template<typename... _Args, int... _Indexes> 1247 _Result 1248 __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>) 1249 { 1250 return _M_f(_Mu<_Bound_args>() 1251 (_GLIBCXX_TR1 get<_Indexes>(_M_bound_args), __args)...); 1252 } 1253 1254 // Call as const 1255 template<typename... _Args, int... _Indexes> 1256 _Result 1257 __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>) const 1258 { 1259 return _M_f(_Mu<_Bound_args>() 1260 (_GLIBCXX_TR1 get<_Indexes>(_M_bound_args), __args)...); 1261 } 1262 1263 // Call as volatile 1264 template<typename... _Args, int... _Indexes> 1265 _Result 1266 __call(const tuple<_Args...>& __args, 1267 _Index_tuple<_Indexes...>) volatile 1268 { 1269 return _M_f(_Mu<_Bound_args>() 1270 (_GLIBCXX_TR1 get<_Indexes>(_M_bound_args), __args)...); 1271 } 1272 1273 // Call as const volatile 1274 template<typename... _Args, int... _Indexes> 1275 _Result 1276 __call(const tuple<_Args...>& __args, 1277 _Index_tuple<_Indexes...>) const volatile 1278 { 1279 return _M_f(_Mu<_Bound_args>() 1280 (_GLIBCXX_TR1 get<_Indexes>(_M_bound_args), __args)...); 1281 } 1282 1283 public: 1284 typedef _Result result_type; 1285 1286 explicit 1287 _Bind_result(_Functor __f, _Bound_args... __bound_args) 1288 : _M_f(__f), _M_bound_args(__bound_args...) { } 1289 1290 // Call unqualified 1291 template<typename... _Args> 1292 result_type 1293 operator()(_Args&... __args) 1294 { 1295 return this->__call(_GLIBCXX_TR1 tie(__args...), _Bound_indexes()); 1296 } 1297 1298 // Call as const 1299 template<typename... _Args> 1300 result_type 1301 operator()(_Args&... __args) const 1302 { 1303 return this->__call(_GLIBCXX_TR1 tie(__args...), _Bound_indexes()); 1304 } 1305 1306 // Call as volatile 1307 template<typename... _Args> 1308 result_type 1309 operator()(_Args&... __args) volatile 1310 { 1311 return this->__call(_GLIBCXX_TR1 tie(__args...), _Bound_indexes()); 1312 } 1313 1314 // Call as const volatile 1315 template<typename... _Args> 1316 result_type 1317 operator()(_Args&... __args) const volatile 1318 { 1319 return this->__call(_GLIBCXX_TR1 tie(__args...), _Bound_indexes()); 1320 } 1321 }; 1322 1323 /// Class template _Bind is always a bind expression. 1324 template<typename _Signature> 1325 struct is_bind_expression<_Bind<_Signature> > 1326 { static const bool value = true; }; 1327 1328 template<typename _Signature> 1329 const bool is_bind_expression<_Bind<_Signature> >::value; 1330 1331 /// Class template _Bind_result is always a bind expression. 1332 template<typename _Result, typename _Signature> 1333 struct is_bind_expression<_Bind_result<_Result, _Signature> > 1334 { static const bool value = true; }; 1335 1336 template<typename _Result, typename _Signature> 1337 const bool is_bind_expression<_Bind_result<_Result, _Signature> >::value; 1338 1339 /// bind 1340 template<typename _Functor, typename... _ArgTypes> 1341 inline 1342 _Bind<typename _Maybe_wrap_member_pointer<_Functor>::type(_ArgTypes...)> 1343 bind(_Functor __f, _ArgTypes... __args) 1344 { 1345 typedef _Maybe_wrap_member_pointer<_Functor> __maybe_type; 1346 typedef typename __maybe_type::type __functor_type; 1347 typedef _Bind<__functor_type(_ArgTypes...)> __result_type; 1348 return __result_type(__maybe_type::__do_wrap(__f), __args...); 1349 } 1350 1351 template<typename _Result, typename _Functor, typename... _ArgTypes> 1352 inline 1353 _Bind_result<_Result, 1354 typename _Maybe_wrap_member_pointer<_Functor>::type 1355 (_ArgTypes...)> 1356 bind(_Functor __f, _ArgTypes... __args) 1357 { 1358 typedef _Maybe_wrap_member_pointer<_Functor> __maybe_type; 1359 typedef typename __maybe_type::type __functor_type; 1360 typedef _Bind_result<_Result, __functor_type(_ArgTypes...)> 1361 __result_type; 1362 return __result_type(__maybe_type::__do_wrap(__f), __args...); 1363 } 1364 1365 /** 1366 * @brief Exception class thrown when class template function's 1367 * operator() is called with an empty target. 1368 * 1369 */ 1370 class bad_function_call : public std::exception { }; 1371 1372 /** 1373 * The integral constant expression 0 can be converted into a 1374 * pointer to this type. It is used by the function template to 1375 * accept NULL pointers. 1376 */ 1377 struct _M_clear_type; 1378 1379 /** 1380 * Trait identifying "location-invariant" types, meaning that the 1381 * address of the object (or any of its members) will not escape. 1382 * Also implies a trivial copy constructor and assignment operator. 1383 */ 1384 template<typename _Tp> 1385 struct __is_location_invariant 1386 : integral_constant<bool, 1387 (is_pointer<_Tp>::value 1388 || is_member_pointer<_Tp>::value)> 1389 { 1390 }; 1391 1392 class _Undefined_class; 1393 1394 union _Nocopy_types 1395 { 1396 void* _M_object; 1397 const void* _M_const_object; 1398 void (*_M_function_pointer)(); 1399 void (_Undefined_class::*_M_member_pointer)(); 1400 }; 1401 1402 union _Any_data 1403 { 1404 void* _M_access() { return &_M_pod_data[0]; } 1405 const void* _M_access() const { return &_M_pod_data[0]; } 1406 1407 template<typename _Tp> 1408 _Tp& 1409 _M_access() 1410 { return *static_cast<_Tp*>(_M_access()); } 1411 1412 template<typename _Tp> 1413 const _Tp& 1414 _M_access() const 1415 { return *static_cast<const _Tp*>(_M_access()); } 1416 1417 _Nocopy_types _M_unused; 1418 char _M_pod_data[sizeof(_Nocopy_types)]; 1419 }; 1420 1421 enum _Manager_operation 1422 { 1423 __get_type_info, 1424 __get_functor_ptr, 1425 __clone_functor, 1426 __destroy_functor 1427 }; 1428 1429 // Simple type wrapper that helps avoid annoying const problems 1430 // when casting between void pointers and pointers-to-pointers. 1431 template<typename _Tp> 1432 struct _Simple_type_wrapper 1433 { 1434 _Simple_type_wrapper(_Tp __value) : __value(__value) { } 1435 1436 _Tp __value; 1437 }; 1438 1439 template<typename _Tp> 1440 struct __is_location_invariant<_Simple_type_wrapper<_Tp> > 1441 : __is_location_invariant<_Tp> 1442 { 1443 }; 1444 1445 // Converts a reference to a function object into a callable 1446 // function object. 1447 template<typename _Functor> 1448 inline _Functor& 1449 __callable_functor(_Functor& __f) 1450 { return __f; } 1451 1452 template<typename _Member, typename _Class> 1453 inline _Mem_fn<_Member _Class::*> 1454 __callable_functor(_Member _Class::* &__p) 1455 { return mem_fn(__p); } 1456 1457 template<typename _Member, typename _Class> 1458 inline _Mem_fn<_Member _Class::*> 1459 __callable_functor(_Member _Class::* const &__p) 1460 { return mem_fn(__p); } 1461 1462 template<typename _Signature> 1463 class function; 1464 1465 /// Base class of all polymorphic function object wrappers. 1466 class _Function_base 1467 { 1468 public: 1469 static const std::size_t _M_max_size = sizeof(_Nocopy_types); 1470 static const std::size_t _M_max_align = __alignof__(_Nocopy_types); 1471 1472 template<typename _Functor> 1473 class _Base_manager 1474 { 1475 protected: 1476 static const bool __stored_locally = 1477 (__is_location_invariant<_Functor>::value 1478 && sizeof(_Functor) <= _M_max_size 1479 && __alignof__(_Functor) <= _M_max_align 1480 && (_M_max_align % __alignof__(_Functor) == 0)); 1481 1482 typedef integral_constant<bool, __stored_locally> _Local_storage; 1483 1484 // Retrieve a pointer to the function object 1485 static _Functor* 1486 _M_get_pointer(const _Any_data& __source) 1487 { 1488 const _Functor* __ptr = 1489 __stored_locally? &__source._M_access<_Functor>() 1490 /* have stored a pointer */ : __source._M_access<_Functor*>(); 1491 return const_cast<_Functor*>(__ptr); 1492 } 1493 1494 // Clone a location-invariant function object that fits within 1495 // an _Any_data structure. 1496 static void 1497 _M_clone(_Any_data& __dest, const _Any_data& __source, true_type) 1498 { 1499 new (__dest._M_access()) _Functor(__source._M_access<_Functor>()); 1500 } 1501 1502 // Clone a function object that is not location-invariant or 1503 // that cannot fit into an _Any_data structure. 1504 static void 1505 _M_clone(_Any_data& __dest, const _Any_data& __source, false_type) 1506 { 1507 __dest._M_access<_Functor*>() = 1508 new _Functor(*__source._M_access<_Functor*>()); 1509 } 1510 1511 // Destroying a location-invariant object may still require 1512 // destruction. 1513 static void 1514 _M_destroy(_Any_data& __victim, true_type) 1515 { 1516 __victim._M_access<_Functor>().~_Functor(); 1517 } 1518 1519 // Destroying an object located on the heap. 1520 static void 1521 _M_destroy(_Any_data& __victim, false_type) 1522 { 1523 delete __victim._M_access<_Functor*>(); 1524 } 1525 1526 public: 1527 static bool 1528 _M_manager(_Any_data& __dest, const _Any_data& __source, 1529 _Manager_operation __op) 1530 { 1531 switch (__op) 1532 { 1533 #ifdef __GXX_RTTI 1534 case __get_type_info: 1535 __dest._M_access<const type_info*>() = &typeid(_Functor); 1536 break; 1537 #endif 1538 case __get_functor_ptr: 1539 __dest._M_access<_Functor*>() = _M_get_pointer(__source); 1540 break; 1541 1542 case __clone_functor: 1543 _M_clone(__dest, __source, _Local_storage()); 1544 break; 1545 1546 case __destroy_functor: 1547 _M_destroy(__dest, _Local_storage()); 1548 break; 1549 } 1550 return false; 1551 } 1552 1553 static void 1554 _M_init_functor(_Any_data& __functor, const _Functor& __f) 1555 { _M_init_functor(__functor, __f, _Local_storage()); } 1556 1557 template<typename _Signature> 1558 static bool 1559 _M_not_empty_function(const function<_Signature>& __f) 1560 { return __f; } 1561 1562 template<typename _Tp> 1563 static bool 1564 _M_not_empty_function(const _Tp*& __fp) 1565 { return __fp; } 1566 1567 template<typename _Class, typename _Tp> 1568 static bool 1569 _M_not_empty_function(_Tp _Class::* const& __mp) 1570 { return __mp; } 1571 1572 template<typename _Tp> 1573 static bool 1574 _M_not_empty_function(const _Tp&) 1575 { return true; } 1576 1577 private: 1578 static void 1579 _M_init_functor(_Any_data& __functor, const _Functor& __f, true_type) 1580 { new (__functor._M_access()) _Functor(__f); } 1581 1582 static void 1583 _M_init_functor(_Any_data& __functor, const _Functor& __f, false_type) 1584 { __functor._M_access<_Functor*>() = new _Functor(__f); } 1585 }; 1586 1587 template<typename _Functor> 1588 class _Ref_manager : public _Base_manager<_Functor*> 1589 { 1590 typedef _Function_base::_Base_manager<_Functor*> _Base; 1591 1592 public: 1593 static bool 1594 _M_manager(_Any_data& __dest, const _Any_data& __source, 1595 _Manager_operation __op) 1596 { 1597 switch (__op) 1598 { 1599 #ifdef __GXX_RTTI 1600 case __get_type_info: 1601 __dest._M_access<const type_info*>() = &typeid(_Functor); 1602 break; 1603 #endif 1604 case __get_functor_ptr: 1605 __dest._M_access<_Functor*>() = *_Base::_M_get_pointer(__source); 1606 return is_const<_Functor>::value; 1607 break; 1608 1609 default: 1610 _Base::_M_manager(__dest, __source, __op); 1611 } 1612 return false; 1613 } 1614 1615 static void 1616 _M_init_functor(_Any_data& __functor, reference_wrapper<_Functor> __f) 1617 { 1618 // TBD: Use address_of function instead. 1619 _Base::_M_init_functor(__functor, &__f.get()); 1620 } 1621 }; 1622 1623 _Function_base() : _M_manager(0) { } 1624 1625 ~_Function_base() 1626 { 1627 if (_M_manager) 1628 _M_manager(_M_functor, _M_functor, __destroy_functor); 1629 } 1630 1631 1632 bool _M_empty() const { return !_M_manager; } 1633 1634 typedef bool (*_Manager_type)(_Any_data&, const _Any_data&, 1635 _Manager_operation); 1636 1637 _Any_data _M_functor; 1638 _Manager_type _M_manager; 1639 }; 1640 1641 template<typename _Signature, typename _Functor> 1642 class _Function_handler; 1643 1644 template<typename _Res, typename _Functor, typename... _ArgTypes> 1645 class _Function_handler<_Res(_ArgTypes...), _Functor> 1646 : public _Function_base::_Base_manager<_Functor> 1647 { 1648 typedef _Function_base::_Base_manager<_Functor> _Base; 1649 1650 public: 1651 static _Res 1652 _M_invoke(const _Any_data& __functor, _ArgTypes... __args) 1653 { 1654 return (*_Base::_M_get_pointer(__functor))(__args...); 1655 } 1656 }; 1657 1658 template<typename _Functor, typename... _ArgTypes> 1659 class _Function_handler<void(_ArgTypes...), _Functor> 1660 : public _Function_base::_Base_manager<_Functor> 1661 { 1662 typedef _Function_base::_Base_manager<_Functor> _Base; 1663 1664 public: 1665 static void 1666 _M_invoke(const _Any_data& __functor, _ArgTypes... __args) 1667 { 1668 (*_Base::_M_get_pointer(__functor))(__args...); 1669 } 1670 }; 1671 1672 template<typename _Res, typename _Functor, typename... _ArgTypes> 1673 class _Function_handler<_Res(_ArgTypes...), reference_wrapper<_Functor> > 1674 : public _Function_base::_Ref_manager<_Functor> 1675 { 1676 typedef _Function_base::_Ref_manager<_Functor> _Base; 1677 1678 public: 1679 static _Res 1680 _M_invoke(const _Any_data& __functor, _ArgTypes... __args) 1681 { 1682 return 1683 __callable_functor(**_Base::_M_get_pointer(__functor))(__args...); 1684 } 1685 }; 1686 1687 template<typename _Functor, typename... _ArgTypes> 1688 class _Function_handler<void(_ArgTypes...), reference_wrapper<_Functor> > 1689 : public _Function_base::_Ref_manager<_Functor> 1690 { 1691 typedef _Function_base::_Ref_manager<_Functor> _Base; 1692 1693 public: 1694 static void 1695 _M_invoke(const _Any_data& __functor, _ArgTypes... __args) 1696 { 1697 __callable_functor(**_Base::_M_get_pointer(__functor))(__args...); 1698 } 1699 }; 1700 1701 template<typename _Class, typename _Member, typename _Res, 1702 typename... _ArgTypes> 1703 class _Function_handler<_Res(_ArgTypes...), _Member _Class::*> 1704 : public _Function_handler<void(_ArgTypes...), _Member _Class::*> 1705 { 1706 typedef _Function_handler<void(_ArgTypes...), _Member _Class::*> 1707 _Base; 1708 1709 public: 1710 static _Res 1711 _M_invoke(const _Any_data& __functor, _ArgTypes... __args) 1712 { 1713 return _GLIBCXX_TR1 1714 mem_fn(_Base::_M_get_pointer(__functor)->__value)(__args...); 1715 } 1716 }; 1717 1718 template<typename _Class, typename _Member, typename... _ArgTypes> 1719 class _Function_handler<void(_ArgTypes...), _Member _Class::*> 1720 : public _Function_base::_Base_manager< 1721 _Simple_type_wrapper< _Member _Class::* > > 1722 { 1723 typedef _Member _Class::* _Functor; 1724 typedef _Simple_type_wrapper<_Functor> _Wrapper; 1725 typedef _Function_base::_Base_manager<_Wrapper> _Base; 1726 1727 public: 1728 static bool 1729 _M_manager(_Any_data& __dest, const _Any_data& __source, 1730 _Manager_operation __op) 1731 { 1732 switch (__op) 1733 { 1734 #ifdef __GXX_RTTI 1735 case __get_type_info: 1736 __dest._M_access<const type_info*>() = &typeid(_Functor); 1737 break; 1738 #endif 1739 case __get_functor_ptr: 1740 __dest._M_access<_Functor*>() = 1741 &_Base::_M_get_pointer(__source)->__value; 1742 break; 1743 1744 default: 1745 _Base::_M_manager(__dest, __source, __op); 1746 } 1747 return false; 1748 } 1749 1750 static void 1751 _M_invoke(const _Any_data& __functor, _ArgTypes... __args) 1752 { 1753 _GLIBCXX_TR1 1754 mem_fn(_Base::_M_get_pointer(__functor)->__value)(__args...); 1755 } 1756 }; 1757 1758 /// class function 1759 template<typename _Res, typename... _ArgTypes> 1760 class function<_Res(_ArgTypes...)> 1761 : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>, 1762 private _Function_base 1763 { 1764 /// This class is used to implement the safe_bool idiom. 1765 struct _Hidden_type 1766 { 1767 _Hidden_type* _M_bool; 1768 }; 1769 1770 /// This typedef is used to implement the safe_bool idiom. 1771 typedef _Hidden_type* _Hidden_type::* _Safe_bool; 1772 1773 typedef _Res _Signature_type(_ArgTypes...); 1774 1775 struct _Useless { }; 1776 1777 public: 1778 typedef _Res result_type; 1779 1780 // [3.7.2.1] construct/copy/destroy 1781 1782 /** 1783 * @brief Default construct creates an empty function call wrapper. 1784 * @post @c !(bool)*this 1785 */ 1786 function() : _Function_base() { } 1787 1788 /** 1789 * @brief Default construct creates an empty function call wrapper. 1790 * @post @c !(bool)*this 1791 */ 1792 function(_M_clear_type*) : _Function_base() { } 1793 1794 /** 1795 * @brief %Function copy constructor. 1796 * @param x A %function object with identical call signature. 1797 * @pre @c (bool)*this == (bool)x 1798 * 1799 * The newly-created %function contains a copy of the target of @a 1800 * x (if it has one). 1801 */ 1802 function(const function& __x); 1803 1804 /** 1805 * @brief Builds a %function that targets a copy of the incoming 1806 * function object. 1807 * @param f A %function object that is callable with parameters of 1808 * type @c T1, @c T2, ..., @c TN and returns a value convertible 1809 * to @c Res. 1810 * 1811 * The newly-created %function object will target a copy of @a 1812 * f. If @a f is @c reference_wrapper<F>, then this function 1813 * object will contain a reference to the function object @c 1814 * f.get(). If @a f is a NULL function pointer or NULL 1815 * pointer-to-member, the newly-created object will be empty. 1816 * 1817 * If @a f is a non-NULL function pointer or an object of type @c 1818 * reference_wrapper<F>, this function will not throw. 1819 */ 1820 template<typename _Functor> 1821 function(_Functor __f, 1822 typename __gnu_cxx::__enable_if< 1823 !is_integral<_Functor>::value, _Useless>::__type 1824 = _Useless()); 1825 1826 /** 1827 * @brief %Function assignment operator. 1828 * @param x A %function with identical call signature. 1829 * @post @c (bool)*this == (bool)x 1830 * @returns @c *this 1831 * 1832 * The target of @a x is copied to @c *this. If @a x has no 1833 * target, then @c *this will be empty. 1834 * 1835 * If @a x targets a function pointer or a reference to a function 1836 * object, then this operation will not throw an exception. 1837 */ 1838 function& 1839 operator=(const function& __x) 1840 { 1841 function(__x).swap(*this); 1842 return *this; 1843 } 1844 1845 /** 1846 * @brief %Function assignment to zero. 1847 * @post @c !(bool)*this 1848 * @returns @c *this 1849 * 1850 * The target of @a *this is deallocated, leaving it empty. 1851 */ 1852 function& 1853 operator=(_M_clear_type*) 1854 { 1855 if (_M_manager) 1856 { 1857 _M_manager(_M_functor, _M_functor, __destroy_functor); 1858 _M_manager = 0; 1859 _M_invoker = 0; 1860 } 1861 return *this; 1862 } 1863 1864 /** 1865 * @brief %Function assignment to a new target. 1866 * @param f A %function object that is callable with parameters of 1867 * type @c T1, @c T2, ..., @c TN and returns a value convertible 1868 * to @c Res. 1869 * @return @c *this 1870 * 1871 * This %function object wrapper will target a copy of @a 1872 * f. If @a f is @c reference_wrapper<F>, then this function 1873 * object will contain a reference to the function object @c 1874 * f.get(). If @a f is a NULL function pointer or NULL 1875 * pointer-to-member, @c this object will be empty. 1876 * 1877 * If @a f is a non-NULL function pointer or an object of type @c 1878 * reference_wrapper<F>, this function will not throw. 1879 */ 1880 template<typename _Functor> 1881 typename __gnu_cxx::__enable_if<!is_integral<_Functor>::value, 1882 function&>::__type 1883 operator=(_Functor __f) 1884 { 1885 function(__f).swap(*this); 1886 return *this; 1887 } 1888 1889 // [3.7.2.2] function modifiers 1890 1891 /** 1892 * @brief Swap the targets of two %function objects. 1893 * @param f A %function with identical call signature. 1894 * 1895 * Swap the targets of @c this function object and @a f. This 1896 * function will not throw an exception. 1897 */ 1898 void swap(function& __x) 1899 { 1900 _Any_data __old_functor = _M_functor; 1901 _M_functor = __x._M_functor; 1902 __x._M_functor = __old_functor; 1903 _Manager_type __old_manager = _M_manager; 1904 _M_manager = __x._M_manager; 1905 __x._M_manager = __old_manager; 1906 _Invoker_type __old_invoker = _M_invoker; 1907 _M_invoker = __x._M_invoker; 1908 __x._M_invoker = __old_invoker; 1909 } 1910 1911 // [3.7.2.3] function capacity 1912 1913 /** 1914 * @brief Determine if the %function wrapper has a target. 1915 * 1916 * @return @c true when this %function object contains a target, 1917 * or @c false when it is empty. 1918 * 1919 * This function will not throw an exception. 1920 */ 1921 operator _Safe_bool() const 1922 { 1923 if (_M_empty()) 1924 return 0; 1925 else 1926 return &_Hidden_type::_M_bool; 1927 } 1928 1929 // [3.7.2.4] function invocation 1930 1931 /** 1932 * @brief Invokes the function targeted by @c *this. 1933 * @returns the result of the target. 1934 * @throws bad_function_call when @c !(bool)*this 1935 * 1936 * The function call operator invokes the target function object 1937 * stored by @c this. 1938 */ 1939 _Res operator()(_ArgTypes... __args) const; 1940 1941 #ifdef __GXX_RTTI 1942 // [3.7.2.5] function target access 1943 /** 1944 * @brief Determine the type of the target of this function object 1945 * wrapper. 1946 * 1947 * @returns the type identifier of the target function object, or 1948 * @c typeid(void) if @c !(bool)*this. 1949 * 1950 * This function will not throw an exception. 1951 */ 1952 const type_info& target_type() const; 1953 1954 /** 1955 * @brief Access the stored target function object. 1956 * 1957 * @return Returns a pointer to the stored target function object, 1958 * if @c typeid(Functor).equals(target_type()); otherwise, a NULL 1959 * pointer. 1960 * 1961 * This function will not throw an exception. 1962 */ 1963 template<typename _Functor> _Functor* target(); 1964 1965 /// @overload 1966 template<typename _Functor> const _Functor* target() const; 1967 #endif 1968 1969 private: 1970 // [3.7.2.6] undefined operators 1971 template<typename _Function> 1972 void operator==(const function<_Function>&) const; 1973 template<typename _Function> 1974 void operator!=(const function<_Function>&) const; 1975 1976 typedef _Res (*_Invoker_type)(const _Any_data&, _ArgTypes...); 1977 _Invoker_type _M_invoker; 1978 }; 1979 1980 template<typename _Res, typename... _ArgTypes> 1981 function<_Res(_ArgTypes...)>:: 1982 function(const function& __x) 1983 : _Function_base() 1984 { 1985 if (__x) 1986 { 1987 _M_invoker = __x._M_invoker; 1988 _M_manager = __x._M_manager; 1989 __x._M_manager(_M_functor, __x._M_functor, __clone_functor); 1990 } 1991 } 1992 1993 template<typename _Res, typename... _ArgTypes> 1994 template<typename _Functor> 1995 function<_Res(_ArgTypes...)>:: 1996 function(_Functor __f, 1997 typename __gnu_cxx::__enable_if< 1998 !is_integral<_Functor>::value, _Useless>::__type) 1999 : _Function_base() 2000 { 2001 typedef _Function_handler<_Signature_type, _Functor> _My_handler; 2002 2003 if (_My_handler::_M_not_empty_function(__f)) 2004 { 2005 _M_invoker = &_My_handler::_M_invoke; 2006 _M_manager = &_My_handler::_M_manager; 2007 _My_handler::_M_init_functor(_M_functor, __f); 2008 } 2009 } 2010 2011 template<typename _Res, typename... _ArgTypes> 2012 _Res 2013 function<_Res(_ArgTypes...)>:: 2014 operator()(_ArgTypes... __args) const 2015 { 2016 if (_M_empty()) 2017 { 2018 #if __EXCEPTIONS 2019 throw bad_function_call(); 2020 #else 2021 __builtin_abort(); 2022 #endif 2023 } 2024 return _M_invoker(_M_functor, __args...); 2025 } 2026 2027 #ifdef __GXX_RTTI 2028 template<typename _Res, typename... _ArgTypes> 2029 const type_info& 2030 function<_Res(_ArgTypes...)>:: 2031 target_type() const 2032 { 2033 if (_M_manager) 2034 { 2035 _Any_data __typeinfo_result; 2036 _M_manager(__typeinfo_result, _M_functor, __get_type_info); 2037 return *__typeinfo_result._M_access<const type_info*>(); 2038 } 2039 else 2040 return typeid(void); 2041 } 2042 2043 template<typename _Res, typename... _ArgTypes> 2044 template<typename _Functor> 2045 _Functor* 2046 function<_Res(_ArgTypes...)>:: 2047 target() 2048 { 2049 if (typeid(_Functor) == target_type() && _M_manager) 2050 { 2051 _Any_data __ptr; 2052 if (_M_manager(__ptr, _M_functor, __get_functor_ptr) 2053 && !is_const<_Functor>::value) 2054 return 0; 2055 else 2056 return __ptr._M_access<_Functor*>(); 2057 } 2058 else 2059 return 0; 2060 } 2061 2062 template<typename _Res, typename... _ArgTypes> 2063 template<typename _Functor> 2064 const _Functor* 2065 function<_Res(_ArgTypes...)>:: 2066 target() const 2067 { 2068 if (typeid(_Functor) == target_type() && _M_manager) 2069 { 2070 _Any_data __ptr; 2071 _M_manager(__ptr, _M_functor, __get_functor_ptr); 2072 return __ptr._M_access<const _Functor*>(); 2073 } 2074 else 2075 return 0; 2076 } 2077 #endif 2078 2079 // [3.7.2.7] null pointer comparisons 2080 2081 /** 2082 * @brief Compares a polymorphic function object wrapper against 0 2083 * (the NULL pointer). 2084 * @returns @c true if the wrapper has no target, @c false otherwise 2085 * 2086 * This function will not throw an exception. 2087 */ 2088 template<typename _Signature> 2089 inline bool 2090 operator==(const function<_Signature>& __f, _M_clear_type*) 2091 { return !__f; } 2092 2093 /// @overload 2094 template<typename _Signature> 2095 inline bool 2096 operator==(_M_clear_type*, const function<_Signature>& __f) 2097 { return !__f; } 2098 2099 /** 2100 * @brief Compares a polymorphic function object wrapper against 0 2101 * (the NULL pointer). 2102 * @returns @c false if the wrapper has no target, @c true otherwise 2103 * 2104 * This function will not throw an exception. 2105 */ 2106 template<typename _Signature> 2107 inline bool 2108 operator!=(const function<_Signature>& __f, _M_clear_type*) 2109 { return __f; } 2110 2111 /// @overload 2112 template<typename _Signature> 2113 inline bool 2114 operator!=(_M_clear_type*, const function<_Signature>& __f) 2115 { return __f; } 2116 2117 // [3.7.2.8] specialized algorithms 2118 2119 /** 2120 * @brief Swap the targets of two polymorphic function object wrappers. 2121 * 2122 * This function will not throw an exception. 2123 */ 2124 template<typename _Signature> 2125 inline void 2126 swap(function<_Signature>& __x, function<_Signature>& __y) 2127 { __x.swap(__y); } 2128 2129 _GLIBCXX_END_NAMESPACE_TR1 2130 } 2131
