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