1 // Implementation of std::function -*- C++ -*- 2 3 // Copyright (C) 2004-2020 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 include/bits/std_function.h 26 * This is an internal header file, included by other library headers. 27 * Do not attempt to use it directly. @headername{functional} 28 */ 29 30 #ifndef _GLIBCXX_STD_FUNCTION_H 31 #define _GLIBCXX_STD_FUNCTION_H 1 32 33 #pragma GCC system_header 34 35 #if __cplusplus < 201103L 36 # include <bits/c++0x_warning.h> 37 #else 38 39 #if __cpp_rtti 40 # include <typeinfo> 41 #endif 42 #include <bits/stl_function.h> 43 #include <bits/invoke.h> 44 #include <bits/refwrap.h> 45 #include <bits/functexcept.h> 46 47 namespace std _GLIBCXX_VISIBILITY(default) 48 { 49 _GLIBCXX_BEGIN_NAMESPACE_VERSION 50 51 /** 52 * @brief Exception class thrown when class template function's 53 * operator() is called with an empty target. 54 * @ingroup exceptions 55 */ 56 class bad_function_call : public std::exception 57 { 58 public: 59 virtual ~bad_function_call() noexcept; 60 61 const char* what() const noexcept; 62 }; 63 64 /** 65 * Trait identifying "location-invariant" types, meaning that the 66 * address of the object (or any of its members) will not escape. 67 * Trivially copyable types are location-invariant and users can 68 * specialize this trait for other types. 69 */ 70 template<typename _Tp> 71 struct __is_location_invariant 72 : is_trivially_copyable<_Tp>::type 73 { }; 74 75 class _Undefined_class; 76 77 union _Nocopy_types 78 { 79 void* _M_object; 80 const void* _M_const_object; 81 void (*_M_function_pointer)(); 82 void (_Undefined_class::*_M_member_pointer)(); 83 }; 84 85 union [[gnu::may_alias]] _Any_data 86 { 87 void* _M_access() { return &_M_pod_data[0]; } 88 const void* _M_access() const { return &_M_pod_data[0]; } 89 90 template<typename _Tp> 91 _Tp& 92 _M_access() 93 { return *static_cast<_Tp*>(_M_access()); } 94 95 template<typename _Tp> 96 const _Tp& 97 _M_access() const 98 { return *static_cast<const _Tp*>(_M_access()); } 99 100 _Nocopy_types _M_unused; 101 char _M_pod_data[sizeof(_Nocopy_types)]; 102 }; 103 104 enum _Manager_operation 105 { 106 __get_type_info, 107 __get_functor_ptr, 108 __clone_functor, 109 __destroy_functor 110 }; 111 112 template<typename _Signature> 113 class function; 114 115 /// Base class of all polymorphic function object wrappers. 116 class _Function_base 117 { 118 public: 119 static const size_t _M_max_size = sizeof(_Nocopy_types); 120 static const size_t _M_max_align = __alignof__(_Nocopy_types); 121 122 template<typename _Functor> 123 class _Base_manager 124 { 125 protected: 126 static const bool __stored_locally = 127 (__is_location_invariant<_Functor>::value 128 && sizeof(_Functor) <= _M_max_size 129 && __alignof__(_Functor) <= _M_max_align 130 && (_M_max_align % __alignof__(_Functor) == 0)); 131 132 typedef integral_constant<bool, __stored_locally> _Local_storage; 133 134 // Retrieve a pointer to the function object 135 static _Functor* 136 _M_get_pointer(const _Any_data& __source) 137 { 138 if _GLIBCXX17_CONSTEXPR (__stored_locally) 139 { 140 const _Functor& __f = __source._M_access<_Functor>(); 141 return const_cast<_Functor*>(std::__addressof(__f)); 142 } 143 else // have stored a pointer 144 return __source._M_access<_Functor*>(); 145 } 146 147 // Clone a location-invariant function object that fits within 148 // an _Any_data structure. 149 static void 150 _M_clone(_Any_data& __dest, const _Any_data& __source, true_type) 151 { 152 ::new (__dest._M_access()) _Functor(__source._M_access<_Functor>()); 153 } 154 155 // Clone a function object that is not location-invariant or 156 // that cannot fit into an _Any_data structure. 157 static void 158 _M_clone(_Any_data& __dest, const _Any_data& __source, false_type) 159 { 160 __dest._M_access<_Functor*>() = 161 new _Functor(*__source._M_access<const _Functor*>()); 162 } 163 164 // Destroying a location-invariant object may still require 165 // destruction. 166 static void 167 _M_destroy(_Any_data& __victim, true_type) 168 { 169 __victim._M_access<_Functor>().~_Functor(); 170 } 171 172 // Destroying an object located on the heap. 173 static void 174 _M_destroy(_Any_data& __victim, false_type) 175 { 176 delete __victim._M_access<_Functor*>(); 177 } 178 179 public: 180 static bool 181 _M_manager(_Any_data& __dest, const _Any_data& __source, 182 _Manager_operation __op) 183 { 184 switch (__op) 185 { 186 #if __cpp_rtti 187 case __get_type_info: 188 __dest._M_access<const type_info*>() = &typeid(_Functor); 189 break; 190 #endif 191 case __get_functor_ptr: 192 __dest._M_access<_Functor*>() = _M_get_pointer(__source); 193 break; 194 195 case __clone_functor: 196 _M_clone(__dest, __source, _Local_storage()); 197 break; 198 199 case __destroy_functor: 200 _M_destroy(__dest, _Local_storage()); 201 break; 202 } 203 return false; 204 } 205 206 static void 207 _M_init_functor(_Any_data& __functor, _Functor&& __f) 208 { _M_init_functor(__functor, std::move(__f), _Local_storage()); } 209 210 template<typename _Signature> 211 static bool 212 _M_not_empty_function(const function<_Signature>& __f) 213 { return static_cast<bool>(__f); } 214 215 template<typename _Tp> 216 static bool 217 _M_not_empty_function(_Tp* __fp) 218 { return __fp != nullptr; } 219 220 template<typename _Class, typename _Tp> 221 static bool 222 _M_not_empty_function(_Tp _Class::* __mp) 223 { return __mp != nullptr; } 224 225 template<typename _Tp> 226 static bool 227 _M_not_empty_function(const _Tp&) 228 { return true; } 229 230 private: 231 static void 232 _M_init_functor(_Any_data& __functor, _Functor&& __f, true_type) 233 { ::new (__functor._M_access()) _Functor(std::move(__f)); } 234 235 static void 236 _M_init_functor(_Any_data& __functor, _Functor&& __f, false_type) 237 { __functor._M_access<_Functor*>() = new _Functor(std::move(__f)); } 238 }; 239 240 _Function_base() : _M_manager(nullptr) { } 241 242 ~_Function_base() 243 { 244 if (_M_manager) 245 _M_manager(_M_functor, _M_functor, __destroy_functor); 246 } 247 248 bool _M_empty() const { return !_M_manager; } 249 250 typedef bool (*_Manager_type)(_Any_data&, const _Any_data&, 251 _Manager_operation); 252 253 _Any_data _M_functor; 254 _Manager_type _M_manager; 255 }; 256 257 template<typename _Signature, typename _Functor> 258 class _Function_handler; 259 260 template<typename _Res, typename _Functor, typename... _ArgTypes> 261 class _Function_handler<_Res(_ArgTypes...), _Functor> 262 : public _Function_base::_Base_manager<_Functor> 263 { 264 typedef _Function_base::_Base_manager<_Functor> _Base; 265 266 public: 267 static bool 268 _M_manager(_Any_data& __dest, const _Any_data& __source, 269 _Manager_operation __op) 270 { 271 switch (__op) 272 { 273 #if __cpp_rtti 274 case __get_type_info: 275 __dest._M_access<const type_info*>() = &typeid(_Functor); 276 break; 277 #endif 278 case __get_functor_ptr: 279 __dest._M_access<_Functor*>() = _Base::_M_get_pointer(__source); 280 break; 281 282 default: 283 _Base::_M_manager(__dest, __source, __op); 284 } 285 return false; 286 } 287 288 static _Res 289 _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args) 290 { 291 return std::__invoke_r<_Res>(*_Base::_M_get_pointer(__functor), 292 std::forward<_ArgTypes>(__args)...); 293 } 294 }; 295 296 /** 297 * @brief Primary class template for std::function. 298 * @ingroup functors 299 * 300 * Polymorphic function wrapper. 301 */ 302 template<typename _Res, typename... _ArgTypes> 303 class function<_Res(_ArgTypes...)> 304 : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>, 305 private _Function_base 306 { 307 template<typename _Func, 308 typename _Res2 = __invoke_result<_Func&, _ArgTypes...>> 309 struct _Callable 310 : __is_invocable_impl<_Res2, _Res>::type 311 { }; 312 313 // Used so the return type convertibility checks aren't done when 314 // performing overload resolution for copy construction/assignment. 315 template<typename _Tp> 316 struct _Callable<function, _Tp> : false_type { }; 317 318 template<typename _Cond, typename _Tp> 319 using _Requires = typename enable_if<_Cond::value, _Tp>::type; 320 321 public: 322 typedef _Res result_type; 323 324 // [3.7.2.1] construct/copy/destroy 325 326 /** 327 * @brief Default construct creates an empty function call wrapper. 328 * @post @c !(bool)*this 329 */ 330 function() noexcept 331 : _Function_base() { } 332 333 /** 334 * @brief Creates an empty function call wrapper. 335 * @post @c !(bool)*this 336 */ 337 function(nullptr_t) noexcept 338 : _Function_base() { } 339 340 /** 341 * @brief %Function copy constructor. 342 * @param __x A %function object with identical call signature. 343 * @post @c bool(*this) == bool(__x) 344 * 345 * The newly-created %function contains a copy of the target of @a 346 * __x (if it has one). 347 */ 348 function(const function& __x); 349 350 /** 351 * @brief %Function move constructor. 352 * @param __x A %function object rvalue with identical call signature. 353 * 354 * The newly-created %function contains the target of @a __x 355 * (if it has one). 356 */ 357 function(function&& __x) noexcept : _Function_base() 358 { 359 __x.swap(*this); 360 } 361 362 /** 363 * @brief Builds a %function that targets a copy of the incoming 364 * function object. 365 * @param __f A %function object that is callable with parameters of 366 * type @c T1, @c T2, ..., @c TN and returns a value convertible 367 * to @c Res. 368 * 369 * The newly-created %function object will target a copy of 370 * @a __f. If @a __f is @c reference_wrapper<F>, then this function 371 * object will contain a reference to the function object @c 372 * __f.get(). If @a __f is a NULL function pointer or NULL 373 * pointer-to-member, the newly-created object will be empty. 374 * 375 * If @a __f is a non-NULL function pointer or an object of type @c 376 * reference_wrapper<F>, this function will not throw. 377 */ 378 template<typename _Functor, 379 typename = _Requires<__not_<is_same<_Functor, function>>, void>, 380 typename = _Requires<_Callable<_Functor>, void>> 381 function(_Functor); 382 383 /** 384 * @brief %Function assignment operator. 385 * @param __x A %function with identical call signature. 386 * @post @c (bool)*this == (bool)x 387 * @returns @c *this 388 * 389 * The target of @a __x is copied to @c *this. If @a __x has no 390 * target, then @c *this will be empty. 391 * 392 * If @a __x targets a function pointer or a reference to a function 393 * object, then this operation will not throw an %exception. 394 */ 395 function& 396 operator=(const function& __x) 397 { 398 function(__x).swap(*this); 399 return *this; 400 } 401 402 /** 403 * @brief %Function move-assignment operator. 404 * @param __x A %function rvalue with identical call signature. 405 * @returns @c *this 406 * 407 * The target of @a __x is moved to @c *this. If @a __x has no 408 * target, then @c *this will be empty. 409 * 410 * If @a __x targets a function pointer or a reference to a function 411 * object, then this operation will not throw an %exception. 412 */ 413 function& 414 operator=(function&& __x) noexcept 415 { 416 function(std::move(__x)).swap(*this); 417 return *this; 418 } 419 420 /** 421 * @brief %Function assignment to zero. 422 * @post @c !(bool)*this 423 * @returns @c *this 424 * 425 * The target of @c *this is deallocated, leaving it empty. 426 */ 427 function& 428 operator=(nullptr_t) noexcept 429 { 430 if (_M_manager) 431 { 432 _M_manager(_M_functor, _M_functor, __destroy_functor); 433 _M_manager = nullptr; 434 _M_invoker = nullptr; 435 } 436 return *this; 437 } 438 439 /** 440 * @brief %Function assignment to a new target. 441 * @param __f A %function object that is callable with parameters of 442 * type @c T1, @c T2, ..., @c TN and returns a value convertible 443 * to @c Res. 444 * @return @c *this 445 * 446 * This %function object wrapper will target a copy of @a 447 * __f. If @a __f is @c reference_wrapper<F>, then this function 448 * object will contain a reference to the function object @c 449 * __f.get(). If @a __f is a NULL function pointer or NULL 450 * pointer-to-member, @c this object will be empty. 451 * 452 * If @a __f is a non-NULL function pointer or an object of type @c 453 * reference_wrapper<F>, this function will not throw. 454 */ 455 template<typename _Functor> 456 _Requires<_Callable<typename decay<_Functor>::type>, function&> 457 operator=(_Functor&& __f) 458 { 459 function(std::forward<_Functor>(__f)).swap(*this); 460 return *this; 461 } 462 463 /// @overload 464 template<typename _Functor> 465 function& 466 operator=(reference_wrapper<_Functor> __f) noexcept 467 { 468 function(__f).swap(*this); 469 return *this; 470 } 471 472 // [3.7.2.2] function modifiers 473 474 /** 475 * @brief Swap the targets of two %function objects. 476 * @param __x A %function with identical call signature. 477 * 478 * Swap the targets of @c this function object and @a __f. This 479 * function will not throw an %exception. 480 */ 481 void swap(function& __x) noexcept 482 { 483 std::swap(_M_functor, __x._M_functor); 484 std::swap(_M_manager, __x._M_manager); 485 std::swap(_M_invoker, __x._M_invoker); 486 } 487 488 // [3.7.2.3] function capacity 489 490 /** 491 * @brief Determine if the %function wrapper has a target. 492 * 493 * @return @c true when this %function object contains a target, 494 * or @c false when it is empty. 495 * 496 * This function will not throw an %exception. 497 */ 498 explicit operator bool() const noexcept 499 { return !_M_empty(); } 500 501 // [3.7.2.4] function invocation 502 503 /** 504 * @brief Invokes the function targeted by @c *this. 505 * @returns the result of the target. 506 * @throws bad_function_call when @c !(bool)*this 507 * 508 * The function call operator invokes the target function object 509 * stored by @c this. 510 */ 511 _Res operator()(_ArgTypes... __args) const; 512 513 #if __cpp_rtti 514 // [3.7.2.5] function target access 515 /** 516 * @brief Determine the type of the target of this function object 517 * wrapper. 518 * 519 * @returns the type identifier of the target function object, or 520 * @c typeid(void) if @c !(bool)*this. 521 * 522 * This function will not throw an %exception. 523 */ 524 const type_info& target_type() const noexcept; 525 526 /** 527 * @brief Access the stored target function object. 528 * 529 * @return Returns a pointer to the stored target function object, 530 * if @c typeid(_Functor).equals(target_type()); otherwise, a NULL 531 * pointer. 532 * 533 * This function does not throw exceptions. 534 * 535 * @{ 536 */ 537 template<typename _Functor> _Functor* target() noexcept; 538 539 template<typename _Functor> const _Functor* target() const noexcept; 540 /// @} 541 #endif 542 543 private: 544 using _Invoker_type = _Res (*)(const _Any_data&, _ArgTypes&&...); 545 _Invoker_type _M_invoker; 546 }; 547 548 #if __cpp_deduction_guides >= 201606 549 template<typename> 550 struct __function_guide_helper 551 { }; 552 553 template<typename _Res, typename _Tp, bool _Nx, typename... _Args> 554 struct __function_guide_helper< 555 _Res (_Tp::*) (_Args...) noexcept(_Nx) 556 > 557 { using type = _Res(_Args...); }; 558 559 template<typename _Res, typename _Tp, bool _Nx, typename... _Args> 560 struct __function_guide_helper< 561 _Res (_Tp::*) (_Args...) & noexcept(_Nx) 562 > 563 { using type = _Res(_Args...); }; 564 565 template<typename _Res, typename _Tp, bool _Nx, typename... _Args> 566 struct __function_guide_helper< 567 _Res (_Tp::*) (_Args...) const noexcept(_Nx) 568 > 569 { using type = _Res(_Args...); }; 570 571 template<typename _Res, typename _Tp, bool _Nx, typename... _Args> 572 struct __function_guide_helper< 573 _Res (_Tp::*) (_Args...) const & noexcept(_Nx) 574 > 575 { using type = _Res(_Args...); }; 576 577 template<typename _Res, typename... _ArgTypes> 578 function(_Res(*)(_ArgTypes...)) -> function<_Res(_ArgTypes...)>; 579 580 template<typename _Functor, typename _Signature = typename 581 __function_guide_helper<decltype(&_Functor::operator())>::type> 582 function(_Functor) -> function<_Signature>; 583 #endif 584 585 // Out-of-line member definitions. 586 template<typename _Res, typename... _ArgTypes> 587 function<_Res(_ArgTypes...)>:: 588 function(const function& __x) 589 : _Function_base() 590 { 591 if (static_cast<bool>(__x)) 592 { 593 __x._M_manager(_M_functor, __x._M_functor, __clone_functor); 594 _M_invoker = __x._M_invoker; 595 _M_manager = __x._M_manager; 596 } 597 } 598 599 template<typename _Res, typename... _ArgTypes> 600 template<typename _Functor, typename, typename> 601 function<_Res(_ArgTypes...)>:: 602 function(_Functor __f) 603 : _Function_base() 604 { 605 typedef _Function_handler<_Res(_ArgTypes...), _Functor> _My_handler; 606 607 if (_My_handler::_M_not_empty_function(__f)) 608 { 609 _My_handler::_M_init_functor(_M_functor, std::move(__f)); 610 _M_invoker = &_My_handler::_M_invoke; 611 _M_manager = &_My_handler::_M_manager; 612 } 613 } 614 615 template<typename _Res, typename... _ArgTypes> 616 _Res 617 function<_Res(_ArgTypes...)>:: 618 operator()(_ArgTypes... __args) const 619 { 620 if (_M_empty()) 621 __throw_bad_function_call(); 622 return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...); 623 } 624 625 #if __cpp_rtti 626 template<typename _Res, typename... _ArgTypes> 627 const type_info& 628 function<_Res(_ArgTypes...)>:: 629 target_type() const noexcept 630 { 631 if (_M_manager) 632 { 633 _Any_data __typeinfo_result; 634 _M_manager(__typeinfo_result, _M_functor, __get_type_info); 635 return *__typeinfo_result._M_access<const type_info*>(); 636 } 637 else 638 return typeid(void); 639 } 640 641 template<typename _Res, typename... _ArgTypes> 642 template<typename _Functor> 643 _Functor* 644 function<_Res(_ArgTypes...)>:: 645 target() noexcept 646 { 647 const function* __const_this = this; 648 const _Functor* __func = __const_this->template target<_Functor>(); 649 return const_cast<_Functor*>(__func); 650 } 651 652 template<typename _Res, typename... _ArgTypes> 653 template<typename _Functor> 654 const _Functor* 655 function<_Res(_ArgTypes...)>:: 656 target() const noexcept 657 { 658 if (typeid(_Functor) == target_type() && _M_manager) 659 { 660 _Any_data __ptr; 661 _M_manager(__ptr, _M_functor, __get_functor_ptr); 662 return __ptr._M_access<const _Functor*>(); 663 } 664 else 665 return nullptr; 666 } 667 #endif 668 669 // [20.7.15.2.6] null pointer comparisons 670 671 /** 672 * @brief Compares a polymorphic function object wrapper against 0 673 * (the NULL pointer). 674 * @returns @c true if the wrapper has no target, @c false otherwise 675 * 676 * This function will not throw an %exception. 677 */ 678 template<typename _Res, typename... _Args> 679 inline bool 680 operator==(const function<_Res(_Args...)>& __f, nullptr_t) noexcept 681 { return !static_cast<bool>(__f); } 682 683 #if __cpp_impl_three_way_comparison < 201907L 684 /// @overload 685 template<typename _Res, typename... _Args> 686 inline bool 687 operator==(nullptr_t, const function<_Res(_Args...)>& __f) noexcept 688 { return !static_cast<bool>(__f); } 689 690 /** 691 * @brief Compares a polymorphic function object wrapper against 0 692 * (the NULL pointer). 693 * @returns @c false if the wrapper has no target, @c true otherwise 694 * 695 * This function will not throw an %exception. 696 */ 697 template<typename _Res, typename... _Args> 698 inline bool 699 operator!=(const function<_Res(_Args...)>& __f, nullptr_t) noexcept 700 { return static_cast<bool>(__f); } 701 702 /// @overload 703 template<typename _Res, typename... _Args> 704 inline bool 705 operator!=(nullptr_t, const function<_Res(_Args...)>& __f) noexcept 706 { return static_cast<bool>(__f); } 707 #endif 708 709 // [20.7.15.2.7] specialized algorithms 710 711 /** 712 * @brief Swap the targets of two polymorphic function object wrappers. 713 * 714 * This function will not throw an %exception. 715 */ 716 // _GLIBCXX_RESOLVE_LIB_DEFECTS 717 // 2062. Effect contradictions w/o no-throw guarantee of std::function swaps 718 template<typename _Res, typename... _Args> 719 inline void 720 swap(function<_Res(_Args...)>& __x, function<_Res(_Args...)>& __y) noexcept 721 { __x.swap(__y); } 722 723 #if __cplusplus >= 201703L 724 namespace __detail::__variant 725 { 726 template<typename> struct _Never_valueless_alt; // see <variant> 727 728 // Provide the strong exception-safety guarantee when emplacing a 729 // function into a variant. 730 template<typename _Signature> 731 struct _Never_valueless_alt<std::function<_Signature>> 732 : std::true_type 733 { }; 734 } // namespace __detail::__variant 735 #endif // C++17 736 737 _GLIBCXX_END_NAMESPACE_VERSION 738 } // namespace std 739 740 #endif // C++11 741 #endif // _GLIBCXX_STD_FUNCTION_H 742