]>
Commit | Line | Data |
---|---|---|
c05986b9 JW |
1 | // Implementation of std::reference_wrapper -*- C++ -*- |
2 | ||
99dee823 | 3 | // Copyright (C) 2004-2021 Free Software Foundation, Inc. |
c05986b9 JW |
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 | ||
26bddba3 | 25 | /** @file include/bits/refwrap.h |
c05986b9 JW |
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 | ||
8c6a71e4 JW |
47 | /// @cond undocumented |
48 | ||
00677c48 JW |
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 | ||
c05986b9 JW |
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. | |
00677c48 JW |
132 | template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM> |
133 | struct _Weak_result_type_impl<_Res(_ArgTypes...) _GLIBCXX_NOEXCEPT_QUAL> | |
c05986b9 JW |
134 | { typedef _Res result_type; }; |
135 | ||
00677c48 JW |
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> | |
c05986b9 JW |
139 | { typedef _Res result_type; }; |
140 | ||
141 | /// Retrieve the result type for a function pointer. | |
00677c48 JW |
142 | template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM> |
143 | struct _Weak_result_type_impl<_Res(*)(_ArgTypes...) _GLIBCXX_NOEXCEPT_QUAL> | |
c05986b9 JW |
144 | { typedef _Res result_type; }; |
145 | ||
00677c48 JW |
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> | |
c05986b9 JW |
150 | { typedef _Res result_type; }; |
151 | ||
00677c48 JW |
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 | { }; | |
c05986b9 | 158 | |
00677c48 JW |
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 | }; | |
c05986b9 | 165 | |
00677c48 JW |
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 | { }; | |
c05986b9 JW |
170 | |
171 | /** | |
172 | * Strip top-level cv-qualifiers from the function object and let | |
00677c48 | 173 | * _Weak_result_type_memfun perform the real work. |
c05986b9 JW |
174 | */ |
175 | template<typename _Functor> | |
176 | struct _Weak_result_type | |
00677c48 | 177 | : _Weak_result_type_memfun<typename remove_cv<_Functor>::type> |
c05986b9 JW |
178 | { }; |
179 | ||
aaeac156 | 180 | #if __cplusplus <= 201703L |
c05986b9 JW |
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) | |
00677c48 JW |
221 | template<typename _Res, typename _T1 _GLIBCXX_NOEXCEPT_PARM> |
222 | struct _Reference_wrapper_base<_Res(_T1) _GLIBCXX_NOEXCEPT_QUAL> | |
c05986b9 JW |
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) | |
00677c48 JW |
242 | template<typename _Res, typename _T1, typename _T2 _GLIBCXX_NOEXCEPT_PARM> |
243 | struct _Reference_wrapper_base<_Res(_T1, _T2) _GLIBCXX_NOEXCEPT_QUAL> | |
c05986b9 JW |
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) | |
00677c48 JW |
263 | template<typename _Res, typename _T1 _GLIBCXX_NOEXCEPT_PARM> |
264 | struct _Reference_wrapper_base<_Res(*)(_T1) _GLIBCXX_NOEXCEPT_QUAL> | |
c05986b9 JW |
265 | : unary_function<_T1, _Res> |
266 | { }; | |
267 | ||
268 | // - a function pointer type (binary) | |
00677c48 JW |
269 | template<typename _Res, typename _T1, typename _T2 _GLIBCXX_NOEXCEPT_PARM> |
270 | struct _Reference_wrapper_base<_Res(*)(_T1, _T2) _GLIBCXX_NOEXCEPT_QUAL> | |
c05986b9 JW |
271 | : binary_function<_T1, _T2, _Res> |
272 | { }; | |
273 | ||
00677c48 JW |
274 | template<typename _Tp, bool = is_member_function_pointer<_Tp>::value> |
275 | struct _Reference_wrapper_base_memfun | |
276 | : _Reference_wrapper_base<_Tp> | |
c05986b9 JW |
277 | { }; |
278 | ||
00677c48 JW |
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 | }; | |
aaeac156 | 285 | #endif // ! C++20 |
c05986b9 | 286 | |
8c6a71e4 JW |
287 | /// @endcond |
288 | ||
c05986b9 JW |
289 | /** |
290 | * @brief Primary class template for reference_wrapper. | |
291 | * @ingroup functors | |
c05986b9 JW |
292 | */ |
293 | template<typename _Tp> | |
294 | class reference_wrapper | |
aaeac156 JW |
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. | |
00677c48 | 298 | : public _Reference_wrapper_base_memfun<typename remove_cv<_Tp>::type> |
aaeac156 | 299 | #endif |
c05986b9 JW |
300 | { |
301 | _Tp* _M_data; | |
302 | ||
2670a7aa | 303 | _GLIBCXX20_CONSTEXPR |
7f93abd8 | 304 | static _Tp* _S_fun(_Tp& __r) noexcept { return std::__addressof(__r); } |
2670a7aa | 305 | |
7f93abd8 JW |
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 | ||
c05986b9 JW |
312 | public: |
313 | typedef _Tp type; | |
314 | ||
7f93abd8 JW |
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>()))> | |
2670a7aa | 320 | _GLIBCXX20_CONSTEXPR |
7f93abd8 JW |
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 | { } | |
c05986b9 JW |
325 | |
326 | reference_wrapper(const reference_wrapper&) = default; | |
327 | ||
328 | reference_wrapper& | |
329 | operator=(const reference_wrapper&) = default; | |
330 | ||
2670a7aa | 331 | _GLIBCXX20_CONSTEXPR |
c05986b9 JW |
332 | operator _Tp&() const noexcept |
333 | { return this->get(); } | |
334 | ||
2670a7aa | 335 | _GLIBCXX20_CONSTEXPR |
c05986b9 JW |
336 | _Tp& |
337 | get() const noexcept | |
338 | { return *_M_data; } | |
339 | ||
340 | template<typename... _Args> | |
2670a7aa | 341 | _GLIBCXX20_CONSTEXPR |
c05986b9 JW |
342 | typename result_of<_Tp&(_Args&&...)>::type |
343 | operator()(_Args&&... __args) const | |
344 | { | |
aaeac156 | 345 | #if __cplusplus > 201703L |
72a9fd20 JW |
346 | if constexpr (is_object_v<type>) |
347 | static_assert(sizeof(type), "type must be complete"); | |
aaeac156 | 348 | #endif |
c05986b9 JW |
349 | return std::__invoke(get(), std::forward<_Args>(__args)...); |
350 | } | |
351 | }; | |
352 | ||
7f93abd8 JW |
353 | #if __cpp_deduction_guides |
354 | template<typename _Tp> | |
355 | reference_wrapper(_Tp&) -> reference_wrapper<_Tp>; | |
356 | #endif | |
c05986b9 | 357 | |
8c6a71e4 JW |
358 | /// @relates reference_wrapper @{ |
359 | ||
c05986b9 JW |
360 | /// Denotes a reference should be taken to a variable. |
361 | template<typename _Tp> | |
2670a7aa | 362 | _GLIBCXX20_CONSTEXPR |
c05986b9 JW |
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> | |
2670a7aa | 369 | _GLIBCXX20_CONSTEXPR |
c05986b9 JW |
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 | ||
6e2e575a | 380 | /// std::ref overload to prevent wrapping a reference_wrapper |
c05986b9 | 381 | template<typename _Tp> |
2670a7aa | 382 | _GLIBCXX20_CONSTEXPR |
c05986b9 JW |
383 | inline reference_wrapper<_Tp> |
384 | ref(reference_wrapper<_Tp> __t) noexcept | |
6e2e575a | 385 | { return __t; } |
c05986b9 | 386 | |
6e2e575a | 387 | /// std::cref overload to prevent wrapping a reference_wrapper |
c05986b9 | 388 | template<typename _Tp> |
2670a7aa | 389 | _GLIBCXX20_CONSTEXPR |
c05986b9 JW |
390 | inline reference_wrapper<const _Tp> |
391 | cref(reference_wrapper<_Tp> __t) noexcept | |
6e2e575a | 392 | { return { __t.get() }; } |
c05986b9 | 393 | |
f0b88346 | 394 | /// @} |
c05986b9 JW |
395 | |
396 | _GLIBCXX_END_NAMESPACE_VERSION | |
397 | } // namespace std | |
398 | ||
399 | #endif // C++11 | |
400 | ||
401 | #endif // _GLIBCXX_REFWRAP_H |