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