The C and C++ Include Header Files

/usr/include/c++/11/bits/std_function.h


$ cat -n /usr/include/c++/11/bits/std_function.h

     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	    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