Line data Source code
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 :
45 : namespace 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 187309164 : void* _M_access() { return &_M_pod_data[0]; }
86 187177927 : const void* _M_access() const { return &_M_pod_data[0]; }
87 :
88 : template<typename _Tp>
89 : _Tp&
90 94896190 : _M_access()
91 94896190 : { return *static_cast<_Tp*>(_M_access()); }
92 :
93 : template<typename _Tp>
94 : const _Tp&
95 187185287 : _M_access() const
96 187185287 : { 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 187185287 : _M_get_pointer(const _Any_data& __source)
135 : {
136 : if _GLIBCXX17_CONSTEXPR (__stored_locally)
137 : {
138 93891105 : const _Functor& __f = __source._M_access<_Functor>();
139 93891102 : return const_cast<_Functor*>(std::__addressof(__f));
140 : }
141 : else // have stored a pointer
142 93294182 : 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 92419427 : _M_create(_Any_data& __dest, _Fn&& __f, true_type)
151 : {
152 92419427 : ::new (__dest._M_access()) _Functor(std::forward<_Fn>(__f));
153 92419427 : }
154 :
155 : // Construct a function object on the heap and store a pointer.
156 : template<typename _Fn>
157 : static void
158 1232399 : _M_create(_Any_data& __dest, _Fn&& __f, false_type)
159 : {
160 1232399 : __dest._M_access<_Functor*>()
161 1232399 : = new _Functor(std::forward<_Fn>(__f));
162 1232399 : }
163 :
164 : // Destroy an object stored in the internal buffer.
165 : static void
166 92429678 : _M_destroy(_Any_data& __victim, true_type)
167 : {
168 92429678 : __victim._M_access<_Functor>().~_Functor();
169 92429678 : }
170 :
171 : // Destroy an object located on the heap.
172 : static void
173 1234113 : _M_destroy(_Any_data& __victim, false_type)
174 : {
175 1234113 : delete __victim._M_access<_Functor*>();
176 1234113 : }
177 :
178 : public:
179 : static bool
180 95139508 : _M_manager(_Any_data& __dest, const _Any_data& __source,
181 : _Manager_operation __op)
182 : {
183 95139508 : switch (__op)
184 : {
185 0 : case __get_type_info:
186 : #if __cpp_rtti
187 0 : __dest._M_access<const type_info*>() = &typeid(_Functor);
188 : #else
189 : __dest._M_access<const type_info*>() = nullptr;
190 : #endif
191 0 : break;
192 :
193 0 : case __get_functor_ptr:
194 0 : __dest._M_access<_Functor*>() = _M_get_pointer(__source);
195 0 : break;
196 :
197 1475718 : case __clone_functor:
198 1475718 : _M_init_functor(__dest,
199 1475718 : *const_cast<const _Functor*>(_M_get_pointer(__source)));
200 1475718 : break;
201 :
202 93663791 : case __destroy_functor:
203 93663791 : _M_destroy(__dest, _Local_storage());
204 93663791 : break;
205 : }
206 95139508 : return false;
207 : }
208 :
209 : template<typename _Fn>
210 : static void
211 93651826 : _M_init_functor(_Any_data& __functor, _Fn&& __f)
212 : noexcept(__and_<_Local_storage,
213 : is_nothrow_constructible<_Functor, _Fn>>::value)
214 : {
215 93651826 : _M_create(__functor, std::forward<_Fn>(__f), _Local_storage());
216 93651826 : }
217 :
218 : template<typename _Signature>
219 : static bool
220 1382 : _M_not_empty_function(const function<_Signature>& __f)
221 1382 : { return static_cast<bool>(__f); }
222 :
223 : template<typename _Tp>
224 : static bool
225 3453 : _M_not_empty_function(_Tp* __fp)
226 3453 : { 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 92171273 : _M_not_empty_function(const _Tp&)
236 92171273 : { return true; }
237 : };
238 :
239 185263103 : _Function_base() = default;
240 :
241 185222019 : ~_Function_base()
242 : {
243 185222019 : if (_M_manager)
244 92907010 : _M_manager(_M_functor, _M_functor, __destroy_functor);
245 185222018 : }
246 :
247 278599259 : 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 95139508 : _M_manager(_Any_data& __dest, const _Any_data& __source,
268 : _Manager_operation __op)
269 : {
270 95139508 : switch (__op)
271 : {
272 : #if __cpp_rtti
273 0 : case __get_type_info:
274 0 : __dest._M_access<const type_info*>() = &typeid(_Functor);
275 0 : break;
276 : #endif
277 0 : case __get_functor_ptr:
278 0 : __dest._M_access<_Functor*>() = _Base::_M_get_pointer(__source);
279 0 : break;
280 :
281 95139508 : default:
282 95139508 : _Base::_M_manager(__dest, __source, __op);
283 : }
284 95139508 : return false;
285 : }
286 :
287 : static _Res
288 185709573 : _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
289 : {
290 185709573 : return std::__invoke_r<_Res>(*_Base::_M_get_pointer(__functor),
291 185711584 : 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 105725 : function() noexcept
369 105725 : : _Function_base() { }
370 :
371 : /**
372 : * @brief Creates an empty function call wrapper.
373 : * @post @c !(bool)*this
374 : */
375 1312 : function(nullptr_t) noexcept
376 1312 : : _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 895368 : function(const function& __x)
387 895368 : : _Function_base()
388 : {
389 895368 : if (static_cast<bool>(__x))
390 : {
391 803598 : __x._M_manager(_M_functor, __x._M_functor, __clone_functor);
392 803598 : _M_invoker = __x._M_invoker;
393 803598 : _M_manager = __x._M_manager;
394 : }
395 895368 : }
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 92085980 : function(function&& __x) noexcept
405 92085980 : : _Function_base(), _M_invoker(__x._M_invoker)
406 : {
407 92085978 : if (static_cast<bool>(__x))
408 : {
409 92075812 : _M_functor = __x._M_functor;
410 92075812 : _M_manager = __x._M_manager;
411 92075812 : __x._M_manager = nullptr;
412 92075812 : __x._M_invoker = nullptr;
413 : }
414 92085974 : }
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 92176108 : function(_Functor&& __f)
436 : noexcept(_Handler<_Functor>::template _S_nothrow_init<_Functor>())
437 92176108 : : _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 92176108 : if (_My_handler::_M_not_empty_function(__f))
448 : {
449 92176108 : _My_handler::_M_init_functor(_M_functor,
450 : std::forward<_Functor>(__f));
451 92176108 : _M_invoker = &_My_handler::_M_invoke;
452 92176108 : _M_manager = &_My_handler::_M_manager;
453 : }
454 92176108 : }
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 15435 : operator=(const function& __x)
470 : {
471 15435 : function(__x).swap(*this);
472 15435 : 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 20133 : operator=(function&& __x) noexcept
488 : {
489 20133 : function(std::move(__x)).swap(*this);
490 20133 : 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 40402 : operator=(nullptr_t) noexcept
502 : {
503 40402 : if (_M_manager)
504 : {
505 644 : _M_manager(_M_functor, _M_functor, __destroy_functor);
506 644 : _M_manager = nullptr;
507 644 : _M_invoker = nullptr;
508 : }
509 40402 : 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 2669 : operator=(_Functor&& __f)
531 : noexcept(_Handler<_Functor>::template _S_nothrow_init<_Functor>())
532 : {
533 2669 : function(std::forward<_Functor>(__f)).swap(*this);
534 2669 : 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 38237 : void swap(function& __x) noexcept
556 : {
557 38237 : std::swap(_M_functor, __x._M_functor);
558 38237 : std::swap(_M_manager, __x._M_manager);
559 38237 : std::swap(_M_invoker, __x._M_invoker);
560 38237 : }
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 93153163 : explicit operator bool() const noexcept
573 93153163 : { 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 185451461 : operator()(_ArgTypes... __args) const
587 : {
588 185451461 : if (_M_empty())
589 0 : __throw_bad_function_call();
590 185450697 : 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 0 : swap(function<_Res(_Args...)>& __x, function<_Res(_Args...)>& __y) noexcept
759 0 : { __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
|
