11.2.0/bits/refwrap.h

// Implementation of std::reference_wrapper -*- C++ -*-

// Copyright (C) 2004-2021 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// <http://www.gnu.org/licenses/>.

/** @file include/bits/refwrap.h
 *  This is an internal header file, included by other library headers.
 *  Do not attempt to use it directly. @headername{functional}
 */

#ifndef _GLIBCXX_REFWRAP_H
#define _GLIBCXX_REFWRAP_H 1

#pragma GCC system_header

#if __cplusplus < 201103L
# include <bits/c++0x_warning.h>
#else

#include <bits/move.h>
#include <bits/invoke.h>
#include <bits/stl_function.h> // for unary_function and binary_function

namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

  /// @cond undocumented

  /**
   * Derives from @c unary_function or @c binary_function, or perhaps
   * nothing, depending on the number of arguments provided. The
   * primary template is the basis case, which derives nothing.
   */
  template<typename _Res, typename... _ArgTypes>
    struct _Maybe_unary_or_binary_function { };

  /// Derives from @c unary_function, as appropriate.
  template<typename _Res, typename _T1>
    struct _Maybe_unary_or_binary_function<_Res, _T1>
    : std::unary_function<_T1, _Res> { };

  /// Derives from @c binary_function, as appropriate.
  template<typename _Res, typename _T1, typename _T2>
    struct _Maybe_unary_or_binary_function<_Res, _T1, _T2>
    : std::binary_function<_T1, _T2, _Res> { };

  template<typename _Signature>
    struct _Mem_fn_traits;

  template<typename _Res, typename _Class, typename... _ArgTypes>
    struct _Mem_fn_traits_base
    {
      using __result_type = _Res;
      using __maybe_type
        = _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>;
      using __arity = integral_constant<size_t, sizeof...(_ArgTypes)>;
    };

#define _GLIBCXX_MEM_FN_TRAITS2(_CV, _REF, _LVAL, _RVAL)                \
  template<typename _Res, typename _Class, typename... _ArgTypes>       \
    struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) _CV _REF>      \
    : _Mem_fn_traits_base<_Res, _CV _Class, _ArgTypes...>               \
    {                                                                   \
      using __vararg = false_type;                                      \
    };                                                                  \
  template<typename _Res, typename _Class, typename... _ArgTypes>       \
    struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) _CV _REF>  \
    : _Mem_fn_traits_base<_Res, _CV _Class, _ArgTypes...>               \
    {                                                                   \
      using __vararg = true_type;                                       \
    };

#define _GLIBCXX_MEM_FN_TRAITS(_REF, _LVAL, _RVAL)              \
  _GLIBCXX_MEM_FN_TRAITS2(              , _REF, _LVAL, _RVAL)   \
  _GLIBCXX_MEM_FN_TRAITS2(const         , _REF, _LVAL, _RVAL)   \
  _GLIBCXX_MEM_FN_TRAITS2(volatile      , _REF, _LVAL, _RVAL)   \
  _GLIBCXX_MEM_FN_TRAITS2(const volatile, _REF, _LVAL, _RVAL)

_GLIBCXX_MEM_FN_TRAITS( , true_type, true_type)
_GLIBCXX_MEM_FN_TRAITS(&, true_type, false_type)
_GLIBCXX_MEM_FN_TRAITS(&&, false_type, true_type)

#if __cplusplus > 201402L
_GLIBCXX_MEM_FN_TRAITS(noexcept, true_type, true_type)
_GLIBCXX_MEM_FN_TRAITS(& noexcept, true_type, false_type)
_GLIBCXX_MEM_FN_TRAITS(&& noexcept, false_type, true_type)
#endif

#undef _GLIBCXX_MEM_FN_TRAITS
#undef _GLIBCXX_MEM_FN_TRAITS2

  /// If we have found a result_type, extract it.
  template<typename _Functor, typename = __void_t<>>
    struct _Maybe_get_result_type
    { };

  template<typename _Functor>
    struct _Maybe_get_result_type<_Functor,
                                  __void_t<typename _Functor::result_type>>
    { typedef typename _Functor::result_type result_type; };

  /**
   *  Base class for any function object that has a weak result type, as
   *  defined in 20.8.2 [func.require] of C++11.
  */
  template<typename _Functor>
    struct _Weak_result_type_impl
    : _Maybe_get_result_type<_Functor>
    { };

  /// Retrieve the result type for a function type.
  template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM>
    struct _Weak_result_type_impl<_Res(_ArgTypes...) _GLIBCXX_NOEXCEPT_QUAL>
    { typedef _Res result_type; };

  /// Retrieve the result type for a varargs function type.
  template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM>
    struct _Weak_result_type_impl<_Res(_ArgTypes......) _GLIBCXX_NOEXCEPT_QUAL>
    { typedef _Res result_type; };

  /// Retrieve the result type for a function pointer.
  template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM>
    struct _Weak_result_type_impl<_Res(*)(_ArgTypes...) _GLIBCXX_NOEXCEPT_QUAL>
    { typedef _Res result_type; };

  /// Retrieve the result type for a varargs function pointer.
  template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM>
    struct
    _Weak_result_type_impl<_Res(*)(_ArgTypes......) _GLIBCXX_NOEXCEPT_QUAL>
    { typedef _Res result_type; };

  // Let _Weak_result_type_impl perform the real work.
  template<typename _Functor,
           bool = is_member_function_pointer<_Functor>::value>
    struct _Weak_result_type_memfun
    : _Weak_result_type_impl<_Functor>
    { };

  // A pointer to member function has a weak result type.
  template<typename _MemFunPtr>
    struct _Weak_result_type_memfun<_MemFunPtr, true>
    {
      using result_type = typename _Mem_fn_traits<_MemFunPtr>::__result_type;
    };

  // A pointer to data member doesn't have a weak result type.
  template<typename _Func, typename _Class>
    struct _Weak_result_type_memfun<_Func _Class::*, false>
    { };

  /**
   *  Strip top-level cv-qualifiers from the function object and let
   *  _Weak_result_type_memfun perform the real work.
  */
  template<typename _Functor>
    struct _Weak_result_type
    : _Weak_result_type_memfun<typename remove_cv<_Functor>::type>
    { };

#if __cplusplus <= 201703L
  // Detect nested argument_type.
  template<typename _Tp, typename = __void_t<>>
    struct _Refwrap_base_arg1
    { };

  // Nested argument_type.
  template<typename _Tp>
    struct _Refwrap_base_arg1<_Tp,
                              __void_t<typename _Tp::argument_type>>
    {
      typedef typename _Tp::argument_type argument_type;
    };

  // Detect nested first_argument_type and second_argument_type.
  template<typename _Tp, typename = __void_t<>>
    struct _Refwrap_base_arg2
    { };

  // Nested first_argument_type and second_argument_type.
  template<typename _Tp>
    struct _Refwrap_base_arg2<_Tp,
                              __void_t<typename _Tp::first_argument_type,
                                       typename _Tp::second_argument_type>>
    {
      typedef typename _Tp::first_argument_type first_argument_type;
      typedef typename _Tp::second_argument_type second_argument_type;
    };

  /**
   *  Derives from unary_function or binary_function when it
   *  can. Specializations handle all of the easy cases. The primary
   *  template determines what to do with a class type, which may
   *  derive from both unary_function and binary_function.
  */
  template<typename _Tp>
    struct _Reference_wrapper_base
    : _Weak_result_type<_Tp>, _Refwrap_base_arg1<_Tp>, _Refwrap_base_arg2<_Tp>
    { };

  // - a function type (unary)
  template<typename _Res, typename _T1 _GLIBCXX_NOEXCEPT_PARM>
    struct _Reference_wrapper_base<_Res(_T1) _GLIBCXX_NOEXCEPT_QUAL>
    : unary_function<_T1, _Res>
    { };

  template<typename _Res, typename _T1>
    struct _Reference_wrapper_base<_Res(_T1) const>
    : unary_function<_T1, _Res>
    { };

  template<typename _Res, typename _T1>
    struct _Reference_wrapper_base<_Res(_T1) volatile>
    : unary_function<_T1, _Res>
    { };

  template<typename _Res, typename _T1>
    struct _Reference_wrapper_base<_Res(_T1) const volatile>
    : unary_function<_T1, _Res>
    { };

  // - a function type (binary)
  template<typename _Res, typename _T1, typename _T2 _GLIBCXX_NOEXCEPT_PARM>
    struct _Reference_wrapper_base<_Res(_T1, _T2) _GLIBCXX_NOEXCEPT_QUAL>
    : binary_function<_T1, _T2, _Res>
    { };

  template<typename _Res, typename _T1, typename _T2>
    struct _Reference_wrapper_base<_Res(_T1, _T2) const>
    : binary_function<_T1, _T2, _Res>
    { };

  template<typename _Res, typename _T1, typename _T2>
    struct _Reference_wrapper_base<_Res(_T1, _T2) volatile>
    : binary_function<_T1, _T2, _Res>
    { };

  template<typename _Res, typename _T1, typename _T2>
    struct _Reference_wrapper_base<_Res(_T1, _T2) const volatile>
    : binary_function<_T1, _T2, _Res>
    { };

  // - a function pointer type (unary)
  template<typename _Res, typename _T1 _GLIBCXX_NOEXCEPT_PARM>
    struct _Reference_wrapper_base<_Res(*)(_T1) _GLIBCXX_NOEXCEPT_QUAL>
    : unary_function<_T1, _Res>
    { };

  // - a function pointer type (binary)
  template<typename _Res, typename _T1, typename _T2 _GLIBCXX_NOEXCEPT_PARM>
    struct _Reference_wrapper_base<_Res(*)(_T1, _T2) _GLIBCXX_NOEXCEPT_QUAL>
    : binary_function<_T1, _T2, _Res>
    { };

  template<typename _Tp, bool = is_member_function_pointer<_Tp>::value>
    struct _Reference_wrapper_base_memfun
    : _Reference_wrapper_base<_Tp>
    { };

  template<typename _MemFunPtr>
    struct _Reference_wrapper_base_memfun<_MemFunPtr, true>
    : _Mem_fn_traits<_MemFunPtr>::__maybe_type
    {
      using result_type = typename _Mem_fn_traits<_MemFunPtr>::__result_type;
    };
#endif // ! C++20

  /// @endcond

  /**
   *  @brief Primary class template for reference_wrapper.
   *  @ingroup functors
   */
  template<typename _Tp>
    class reference_wrapper
#if __cplusplus <= 201703L
    // In C++20 std::reference_wrapper<T> allows T to be incomplete,
    // so checking for nested types could result in ODR violations.
    : public _Reference_wrapper_base_memfun<typename remove_cv<_Tp>::type>
#endif
    {
      _Tp* _M_data;

      _GLIBCXX20_CONSTEXPR
      static _Tp* _S_fun(_Tp& __r) noexcept { return std::__addressof(__r); }

      static void _S_fun(_Tp&&) = delete;

      template<typename _Up, typename _Up2 = __remove_cvref_t<_Up>>
        using __not_same
          = typename enable_if<!is_same<reference_wrapper, _Up2>::value>::type;

    public:
      typedef _Tp type;

      // _GLIBCXX_RESOLVE_LIB_DEFECTS
      // 2993. reference_wrapper<T> conversion from T&&
      // 3041. Unnecessary decay in reference_wrapper
      template<typename _Up, typename = __not_same<_Up>, typename
                = decltype(reference_wrapper::_S_fun(std::declval<_Up>()))>
        _GLIBCXX20_CONSTEXPR
        reference_wrapper(_Up&& __uref)
        noexcept(noexcept(reference_wrapper::_S_fun(std::declval<_Up>())))
        : _M_data(reference_wrapper::_S_fun(std::forward<_Up>(__uref)))
        { }

      reference_wrapper(const reference_wrapper&) = default;

      reference_wrapper&
      operator=(const reference_wrapper&) = default;

      _GLIBCXX20_CONSTEXPR
      operator _Tp&() const noexcept
      { return this->get(); }

      _GLIBCXX20_CONSTEXPR
      _Tp&
      get() const noexcept
      { return *_M_data; }

      template<typename... _Args>
        _GLIBCXX20_CONSTEXPR
        typename result_of<_Tp&(_Args&&...)>::type
        operator()(_Args&&... __args) const
        {
#if __cplusplus > 201703L
          if constexpr (is_object_v<type>)
            static_assert(sizeof(type), "type must be complete");
#endif
          return std::__invoke(get(), std::forward<_Args>(__args)...);
        }
    };

#if __cpp_deduction_guides
  template<typename _Tp>
    reference_wrapper(_Tp&) -> reference_wrapper<_Tp>;
#endif

  /// @relates reference_wrapper @{

  /// Denotes a reference should be taken to a variable.
  template<typename _Tp>
    _GLIBCXX20_CONSTEXPR
    inline reference_wrapper<_Tp>
    ref(_Tp& __t) noexcept
    { return reference_wrapper<_Tp>(__t); }

  /// Denotes a const reference should be taken to a variable.
  template<typename _Tp>
    _GLIBCXX20_CONSTEXPR
    inline reference_wrapper<const _Tp>
    cref(const _Tp& __t) noexcept
    { return reference_wrapper<const _Tp>(__t); }

  template<typename _Tp>
    void ref(const _Tp&&) = delete;

  template<typename _Tp>
    void cref(const _Tp&&) = delete;

  /// std::ref overload to prevent wrapping a reference_wrapper
  template<typename _Tp>
    _GLIBCXX20_CONSTEXPR
    inline reference_wrapper<_Tp>
    ref(reference_wrapper<_Tp> __t) noexcept
    { return __t; }

  /// std::cref overload to prevent wrapping a reference_wrapper
  template<typename _Tp>
    _GLIBCXX20_CONSTEXPR
    inline reference_wrapper<const _Tp>
    cref(reference_wrapper<_Tp> __t) noexcept
    { return { __t.get() }; }

  /// @}

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std

#endif // C++11

#endif // _GLIBCXX_REFWRAP_H
Revision:	1166
Committed:	Tue Oct 26 14:22:36 2021 UTC (4 years ago) by rossy
Content type:	text/x-chdr
File size:	13208 byte(s)
Log Message:	Daodan: Replace MinGW build env with an up-to-date MSYS2 env
#	Content
1	// Implementation of std::reference_wrapper -- 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/refwrap.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_REFWRAP_H
31	#define _GLIBCXX_REFWRAP_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 <bits/move.h>
40	#include <bits/invoke.h>
41	#include <bits/stl_function.h> // for unary_function and binary_function
42
43	namespace std _GLIBCXX_VISIBILITY(default)
44	{
45	_GLIBCXX_BEGIN_NAMESPACE_VERSION
46
47	/// @cond undocumented
48
49	/**
50	* Derives from @c unary_function or @c binary_function, or perhaps
51	* nothing, depending on the number of arguments provided. The
52	* primary template is the basis case, which derives nothing.
53	*/
54	template<typename _Res, typename... _ArgTypes>
55	struct _Maybe_unary_or_binary_function { };
56
57	/// Derives from @c unary_function, as appropriate.
58	template<typename _Res, typename _T1>
59	struct _Maybe_unary_or_binary_function<_Res, _T1>
60	: std::unary_function<_T1, _Res> { };
61
62	/// Derives from @c binary_function, as appropriate.
63	template<typename _Res, typename _T1, typename _T2>
64	struct _Maybe_unary_or_binary_function<_Res, _T1, _T2>
65	: std::binary_function<_T1, _T2, _Res> { };
66
67	template<typename _Signature>
68	struct _Mem_fn_traits;
69
70	template<typename _Res, typename _Class, typename... _ArgTypes>
71	struct _Mem_fn_traits_base
72	{
73	using __result_type = _Res;
74	using __maybe_type
75	= _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>;
76	using __arity = integral_constant<size_t, sizeof...(_ArgTypes)>;
77	};
78
79	#define _GLIBCXX_MEM_FN_TRAITS2(_CV, _REF, _LVAL, _RVAL) \
80	template<typename _Res, typename _Class, typename... _ArgTypes> \
81	struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) _CV _REF> \
82	: _Mem_fn_traits_base<_Res, _CV _Class, _ArgTypes...> \
83	{ \
84	using __vararg = false_type; \
85	}; \
86	template<typename _Res, typename _Class, typename... _ArgTypes> \
87	struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) _CV _REF> \
88	: _Mem_fn_traits_base<_Res, _CV _Class, _ArgTypes...> \
89	{ \
90	using __vararg = true_type; \
91	};
92
93	#define _GLIBCXX_MEM_FN_TRAITS(_REF, _LVAL, _RVAL) \
94	_GLIBCXX_MEM_FN_TRAITS2( , _REF, _LVAL, _RVAL) \
95	_GLIBCXX_MEM_FN_TRAITS2(const , _REF, _LVAL, _RVAL) \
96	_GLIBCXX_MEM_FN_TRAITS2(volatile , _REF, _LVAL, _RVAL) \
97	_GLIBCXX_MEM_FN_TRAITS2(const volatile, _REF, _LVAL, _RVAL)
98
99	_GLIBCXX_MEM_FN_TRAITS( , true_type, true_type)
100	_GLIBCXX_MEM_FN_TRAITS(&, true_type, false_type)
101	_GLIBCXX_MEM_FN_TRAITS(&&, false_type, true_type)
102
103	#if __cplusplus > 201402L
104	_GLIBCXX_MEM_FN_TRAITS(noexcept, true_type, true_type)
105	_GLIBCXX_MEM_FN_TRAITS(& noexcept, true_type, false_type)
106	_GLIBCXX_MEM_FN_TRAITS(&& noexcept, false_type, true_type)
107	#endif
108
109	#undef _GLIBCXX_MEM_FN_TRAITS
110	#undef _GLIBCXX_MEM_FN_TRAITS2
111
112	/// If we have found a result_type, extract it.
113	template<typename _Functor, typename = __void_t<>>
114	struct _Maybe_get_result_type
115	{ };
116
117	template<typename _Functor>
118	struct _Maybe_get_result_type<_Functor,
119	__void_t<typename _Functor::result_type>>
120	{ typedef typename _Functor::result_type result_type; };
121
122	/**
123	* Base class for any function object that has a weak result type, as
124	* defined in 20.8.2 [func.require] of C++11.
125	*/
126	template<typename _Functor>
127	struct _Weak_result_type_impl
128	: _Maybe_get_result_type<_Functor>
129	{ };
130
131	/// Retrieve the result type for a function type.
132	template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM>
133	struct _Weak_result_type_impl<_Res(_ArgTypes...) _GLIBCXX_NOEXCEPT_QUAL>
134	{ typedef _Res result_type; };
135
136	/// Retrieve the result type for a varargs function type.
137	template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM>
138	struct _Weak_result_type_impl<_Res(_ArgTypes......) _GLIBCXX_NOEXCEPT_QUAL>
139	{ typedef _Res result_type; };
140
141	/// Retrieve the result type for a function pointer.
142	template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM>
143	struct _Weak_result_type_impl<_Res(*)(_ArgTypes...) _GLIBCXX_NOEXCEPT_QUAL>
144	{ typedef _Res result_type; };
145
146	/// Retrieve the result type for a varargs function pointer.
147	template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM>
148	struct
149	_Weak_result_type_impl<_Res(*)(_ArgTypes......) _GLIBCXX_NOEXCEPT_QUAL>
150	{ typedef _Res result_type; };
151
152	// Let _Weak_result_type_impl perform the real work.
153	template<typename _Functor,
154	bool = is_member_function_pointer<_Functor>::value>
155	struct _Weak_result_type_memfun
156	: _Weak_result_type_impl<_Functor>
157	{ };
158
159	// A pointer to member function has a weak result type.
160	template<typename _MemFunPtr>
161	struct _Weak_result_type_memfun<_MemFunPtr, true>
162	{
163	using result_type = typename _Mem_fn_traits<_MemFunPtr>::__result_type;
164	};
165
166	// A pointer to data member doesn't have a weak result type.
167	template<typename _Func, typename _Class>
168	struct _Weak_result_type_memfun<_Func _Class::*, false>
169	{ };
170
171	/**
172	* Strip top-level cv-qualifiers from the function object and let
173	* _Weak_result_type_memfun perform the real work.
174	*/
175	template<typename _Functor>
176	struct _Weak_result_type
177	: _Weak_result_type_memfun<typename remove_cv<_Functor>::type>
178	{ };
179
180	#if __cplusplus <= 201703L
181	// Detect nested argument_type.
182	template<typename _Tp, typename = __void_t<>>
183	struct _Refwrap_base_arg1
184	{ };
185
186	// Nested argument_type.
187	template<typename _Tp>
188	struct _Refwrap_base_arg1<_Tp,
189	__void_t<typename _Tp::argument_type>>
190	{
191	typedef typename _Tp::argument_type argument_type;
192	};
193
194	// Detect nested first_argument_type and second_argument_type.
195	template<typename _Tp, typename = __void_t<>>
196	struct _Refwrap_base_arg2
197	{ };
198
199	// Nested first_argument_type and second_argument_type.
200	template<typename _Tp>
201	struct _Refwrap_base_arg2<_Tp,
202	__void_t<typename _Tp::first_argument_type,
203	typename _Tp::second_argument_type>>
204	{
205	typedef typename _Tp::first_argument_type first_argument_type;
206	typedef typename _Tp::second_argument_type second_argument_type;
207	};
208
209	/**
210	* Derives from unary_function or binary_function when it
211	* can. Specializations handle all of the easy cases. The primary
212	* template determines what to do with a class type, which may
213	* derive from both unary_function and binary_function.
214	*/
215	template<typename _Tp>
216	struct _Reference_wrapper_base
217	: _Weak_result_type<_Tp>, _Refwrap_base_arg1<_Tp>, _Refwrap_base_arg2<_Tp>
218	{ };
219
220	// - a function type (unary)
221	template<typename _Res, typename _T1 _GLIBCXX_NOEXCEPT_PARM>
222	struct _Reference_wrapper_base<_Res(_T1) _GLIBCXX_NOEXCEPT_QUAL>
223	: unary_function<_T1, _Res>
224	{ };
225
226	template<typename _Res, typename _T1>
227	struct _Reference_wrapper_base<_Res(_T1) const>
228	: unary_function<_T1, _Res>
229	{ };
230
231	template<typename _Res, typename _T1>
232	struct _Reference_wrapper_base<_Res(_T1) volatile>
233	: unary_function<_T1, _Res>
234	{ };
235
236	template<typename _Res, typename _T1>
237	struct _Reference_wrapper_base<_Res(_T1) const volatile>
238	: unary_function<_T1, _Res>
239	{ };
240
241	// - a function type (binary)
242	template<typename _Res, typename _T1, typename _T2 _GLIBCXX_NOEXCEPT_PARM>
243	struct _Reference_wrapper_base<_Res(_T1, _T2) _GLIBCXX_NOEXCEPT_QUAL>
244	: binary_function<_T1, _T2, _Res>
245	{ };
246
247	template<typename _Res, typename _T1, typename _T2>
248	struct _Reference_wrapper_base<_Res(_T1, _T2) const>
249	: binary_function<_T1, _T2, _Res>
250	{ };
251
252	template<typename _Res, typename _T1, typename _T2>
253	struct _Reference_wrapper_base<_Res(_T1, _T2) volatile>
254	: binary_function<_T1, _T2, _Res>
255	{ };
256
257	template<typename _Res, typename _T1, typename _T2>
258	struct _Reference_wrapper_base<_Res(_T1, _T2) const volatile>
259	: binary_function<_T1, _T2, _Res>
260	{ };
261
262	// - a function pointer type (unary)
263	template<typename _Res, typename _T1 _GLIBCXX_NOEXCEPT_PARM>
264	struct _Reference_wrapper_base<_Res(*)(_T1) _GLIBCXX_NOEXCEPT_QUAL>
265	: unary_function<_T1, _Res>
266	{ };
267
268	// - a function pointer type (binary)
269	template<typename _Res, typename _T1, typename _T2 _GLIBCXX_NOEXCEPT_PARM>
270	struct _Reference_wrapper_base<_Res(*)(_T1, _T2) _GLIBCXX_NOEXCEPT_QUAL>
271	: binary_function<_T1, _T2, _Res>
272	{ };
273
274	template<typename _Tp, bool = is_member_function_pointer<_Tp>::value>
275	struct _Reference_wrapper_base_memfun
276	: _Reference_wrapper_base<_Tp>
277	{ };
278
279	template<typename _MemFunPtr>
280	struct _Reference_wrapper_base_memfun<_MemFunPtr, true>
281	: _Mem_fn_traits<_MemFunPtr>::__maybe_type
282	{
283	using result_type = typename _Mem_fn_traits<_MemFunPtr>::__result_type;
284	};
285	#endif // ! C++20
286
287	/// @endcond
288
289	/**
290	* @brief Primary class template for reference_wrapper.
291	* @ingroup functors
292	*/
293	template<typename _Tp>
294	class reference_wrapper
295	#if __cplusplus <= 201703L
296	// In C++20 std::reference_wrapper<T> allows T to be incomplete,
297	// so checking for nested types could result in ODR violations.
298	: public _Reference_wrapper_base_memfun<typename remove_cv<_Tp>::type>
299	#endif
300	{
301	_Tp* _M_data;
302
303	_GLIBCXX20_CONSTEXPR
304	static _Tp* _S_fun(_Tp& __r) noexcept { return std::__addressof(__r); }
305
306	static void _S_fun(_Tp&&) = delete;
307
308	template<typename _Up, typename _Up2 = __remove_cvref_t<_Up>>
309	using __not_same
310	= typename enable_if<!is_same<reference_wrapper, _Up2>::value>::type;
311
312	public:
313	typedef _Tp type;
314
315	// _GLIBCXX_RESOLVE_LIB_DEFECTS
316	// 2993. reference_wrapper<T> conversion from T&&
317	// 3041. Unnecessary decay in reference_wrapper
318	template<typename _Up, typename = __not_same<_Up>, typename
319	= decltype(reference_wrapper::_S_fun(std::declval<_Up>()))>
320	_GLIBCXX20_CONSTEXPR
321	reference_wrapper(_Up&& __uref)
322	noexcept(noexcept(reference_wrapper::_S_fun(std::declval<_Up>())))
323	: _M_data(reference_wrapper::_S_fun(std::forward<_Up>(__uref)))
324	{ }
325
326	reference_wrapper(const reference_wrapper&) = default;
327
328	reference_wrapper&
329	operator=(const reference_wrapper&) = default;
330
331	_GLIBCXX20_CONSTEXPR
332	operator _Tp&() const noexcept
333	{ return this->get(); }
334
335	_GLIBCXX20_CONSTEXPR
336	_Tp&
337	get() const noexcept
338	{ return *_M_data; }
339
340	template<typename... _Args>
341	_GLIBCXX20_CONSTEXPR
342	typename result_of<_Tp&(_Args&&...)>::type
343	operator()(_Args&&... __args) const
344	{
345	#if __cplusplus > 201703L
346	if constexpr (is_object_v<type>)
347	static_assert(sizeof(type), "type must be complete");
348	#endif
349	return std::__invoke(get(), std::forward<_Args>(__args)...);
350	}
351	};
352
353	#if __cpp_deduction_guides
354	template<typename _Tp>
355	reference_wrapper(_Tp&) -> reference_wrapper<_Tp>;
356	#endif
357
358	/// @relates reference_wrapper @{
359
360	/// Denotes a reference should be taken to a variable.
361	template<typename _Tp>
362	_GLIBCXX20_CONSTEXPR
363	inline reference_wrapper<_Tp>
364	ref(_Tp& __t) noexcept
365	{ return reference_wrapper<_Tp>(__t); }
366
367	/// Denotes a const reference should be taken to a variable.
368	template<typename _Tp>
369	_GLIBCXX20_CONSTEXPR
370	inline reference_wrapper<const _Tp>
371	cref(const _Tp& __t) noexcept
372	{ return reference_wrapper<const _Tp>(__t); }
373
374	template<typename _Tp>
375	void ref(const _Tp&&) = delete;
376
377	template<typename _Tp>
378	void cref(const _Tp&&) = delete;
379
380	/// std::ref overload to prevent wrapping a reference_wrapper
381	template<typename _Tp>
382	_GLIBCXX20_CONSTEXPR
383	inline reference_wrapper<_Tp>
384	ref(reference_wrapper<_Tp> __t) noexcept
385	{ return __t; }
386
387	/// std::cref overload to prevent wrapping a reference_wrapper
388	template<typename _Tp>
389	_GLIBCXX20_CONSTEXPR
390	inline reference_wrapper<const _Tp>
391	cref(reference_wrapper<_Tp> __t) noexcept
392	{ return { __t.get() }; }
393
394	/// @}
395
396	_GLIBCXX_END_NAMESPACE_VERSION
397	} // namespace std
398
399	#endif // C++11
400
401	#endif // _GLIBCXX_REFWRAP_H