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

source code of include/c++/11/bits/std_function.h