libstdc++
std_function.h
Go to the documentation of this file.
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  */
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>
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.
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 =
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,
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&
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>>
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
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
Definition: move.h:49
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
Definition: move.h:104
void swap(any &__x, any &__y) noexcept
Exchange the states of two any objects.
Definition: any:428
ISO C++ entities toplevel namespace is std.
Part of RTTI.
Definition: typeinfo:89
Primary class template for reference_wrapper.
Definition: refwrap.h:300
integral_constant
Definition: type_traits:66
is_object
Definition: type_traits:580
is_same
Definition: type_traits:1410
is_trivially_copyable
Definition: type_traits:712
is_constructible
Definition: type_traits:954
is_copy_constructible
Definition: type_traits:986
is_nothrow_constructible
Definition: type_traits:1024
Base class for all library exceptions.
Definition: exception.h:62
Exception class thrown when class template function's operator() is called with an empty target.
Definition: std_function.h:55
const char * what() const noexcept
Base class of all polymorphic function object wrappers.
Definition: std_function.h:115
function & operator=(function &&__x) noexcept
Function move-assignment operator.
Definition: std_function.h:487
function & operator=(nullptr_t) noexcept
Function assignment to zero.
Definition: std_function.h:501
function & operator=(const function &__x)
Function assignment operator.
Definition: std_function.h:469
const type_info & target_type() const noexcept
Determine the type of the target of this function object wrapper.
Definition: std_function.h:605
_Res operator()(_ArgTypes... __args) const
Invokes the function targeted by *this.
Definition: std_function.h:586
void swap(function &__x) noexcept
Swap the targets of two function objects.
Definition: std_function.h:555
_Requires< _Callable< _Functor >, function & > operator=(_Functor &&__f) noexcept(_Handler< _Functor >::template _S_nothrow_init< _Functor >())
Function assignment to a new target.
Definition: std_function.h:530
const _Functor * target() const noexcept
Access the stored target function object.
Definition: std_function.h:642
_Functor * target() noexcept
Access the stored target function object.
Definition: std_function.h:631
function & operator=(reference_wrapper< _Functor > __f) noexcept
This is an overloaded member function, provided for convenience. It differs from the above function o...
Definition: std_function.h:540