1 | // Functor implementations -*- C++ -*- |
2 | |
3 | // Copyright (C) 2001-2024 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 | /* |
26 | * |
27 | * Copyright (c) 1994 |
28 | * Hewlett-Packard Company |
29 | * |
30 | * Permission to use, copy, modify, distribute and sell this software |
31 | * and its documentation for any purpose is hereby granted without fee, |
32 | * provided that the above copyright notice appear in all copies and |
33 | * that both that copyright notice and this permission notice appear |
34 | * in supporting documentation. Hewlett-Packard Company makes no |
35 | * representations about the suitability of this software for any |
36 | * purpose. It is provided "as is" without express or implied warranty. |
37 | * |
38 | * |
39 | * Copyright (c) 1996-1998 |
40 | * Silicon Graphics Computer Systems, Inc. |
41 | * |
42 | * Permission to use, copy, modify, distribute and sell this software |
43 | * and its documentation for any purpose is hereby granted without fee, |
44 | * provided that the above copyright notice appear in all copies and |
45 | * that both that copyright notice and this permission notice appear |
46 | * in supporting documentation. Silicon Graphics makes no |
47 | * representations about the suitability of this software for any |
48 | * purpose. It is provided "as is" without express or implied warranty. |
49 | */ |
50 | |
51 | /** @file bits/stl_function.h |
52 | * This is an internal header file, included by other library headers. |
53 | * Do not attempt to use it directly. @headername{functional} |
54 | */ |
55 | |
56 | #ifndef _STL_FUNCTION_H |
57 | #define _STL_FUNCTION_H 1 |
58 | |
59 | #if __cplusplus > 201103L |
60 | #include <bits/move.h> |
61 | #endif |
62 | |
63 | namespace std _GLIBCXX_VISIBILITY(default) |
64 | { |
65 | _GLIBCXX_BEGIN_NAMESPACE_VERSION |
66 | |
67 | // 20.3.1 base classes |
68 | /** @defgroup functors Function Objects |
69 | * @ingroup utilities |
70 | * |
71 | * Function objects, or _functors_, are objects with an `operator()` |
72 | * defined and accessible. They can be passed as arguments to algorithm |
73 | * templates and used in place of a function pointer. Not only is the |
74 | * resulting expressiveness of the library increased, but the generated |
75 | * code can be more efficient than what you might write by hand. When we |
76 | * refer to _functors_, then, generally we include function pointers in |
77 | * the description as well. |
78 | * |
79 | * Often, functors are only created as temporaries passed to algorithm |
80 | * calls, rather than being created as named variables. |
81 | * |
82 | * Two examples taken from the standard itself follow. To perform a |
83 | * by-element addition of two vectors `a` and `b` containing `double`, |
84 | * and put the result in `a`, use |
85 | * \code |
86 | * transform (a.begin(), a.end(), b.begin(), a.begin(), plus<double>()); |
87 | * \endcode |
88 | * To negate every element in `a`, use |
89 | * \code |
90 | * transform(a.begin(), a.end(), a.begin(), negate<double>()); |
91 | * \endcode |
92 | * The addition and negation functions will usually be inlined directly. |
93 | * |
94 | * An _adaptable function object_ is one which provides nested typedefs |
95 | * `result_type` and either `argument_type` (for a unary function) or |
96 | * `first_argument_type` and `second_argument_type` (for a binary function). |
97 | * Those typedefs are used by function object adaptors such as `bind2nd`. |
98 | * The standard library provides two class templates, `unary_function` and |
99 | * `binary_function`, which define those typedefs and so can be used as |
100 | * base classes of adaptable function objects. |
101 | * |
102 | * Since C++11 the use of function object adaptors has been superseded by |
103 | * more powerful tools such as lambda expressions, `function<>`, and more |
104 | * powerful type deduction (using `auto` and `decltype`). The helpers for |
105 | * defining adaptable function objects are deprecated since C++11, and no |
106 | * longer part of the standard library since C++17. However, they are still |
107 | * defined and used by libstdc++ after C++17, as a conforming extension. |
108 | * |
109 | * @{ |
110 | */ |
111 | |
112 | /** |
113 | * Helper for defining adaptable unary function objects. |
114 | * @deprecated Deprecated in C++11, no longer in the standard since C++17. |
115 | */ |
116 | template<typename _Arg, typename _Result> |
117 | struct unary_function |
118 | { |
119 | /// @c argument_type is the type of the argument |
120 | typedef _Arg argument_type; |
121 | |
122 | /// @c result_type is the return type |
123 | typedef _Result result_type; |
124 | } _GLIBCXX11_DEPRECATED; |
125 | |
126 | /** |
127 | * Helper for defining adaptable binary function objects. |
128 | * @deprecated Deprecated in C++11, no longer in the standard since C++17. |
129 | */ |
130 | template<typename _Arg1, typename _Arg2, typename _Result> |
131 | struct binary_function |
132 | { |
133 | /// @c first_argument_type is the type of the first argument |
134 | typedef _Arg1 first_argument_type; |
135 | |
136 | /// @c second_argument_type is the type of the second argument |
137 | typedef _Arg2 second_argument_type; |
138 | |
139 | /// @c result_type is the return type |
140 | typedef _Result result_type; |
141 | } _GLIBCXX11_DEPRECATED; |
142 | /** @} */ |
143 | |
144 | // 20.3.2 arithmetic |
145 | |
146 | /** @defgroup arithmetic_functors Arithmetic Function Object Classes |
147 | * @ingroup functors |
148 | * |
149 | * The library provides function objects for basic arithmetic operations. |
150 | * See the documentation for @link functors function objects @endlink |
151 | * for examples of their use. |
152 | * |
153 | * @{ |
154 | */ |
155 | |
156 | #if __glibcxx_transparent_operators // C++ >= 14 |
157 | struct __is_transparent; // undefined |
158 | |
159 | template<typename _Tp = void> |
160 | struct plus; |
161 | |
162 | template<typename _Tp = void> |
163 | struct minus; |
164 | |
165 | template<typename _Tp = void> |
166 | struct multiplies; |
167 | |
168 | template<typename _Tp = void> |
169 | struct divides; |
170 | |
171 | template<typename _Tp = void> |
172 | struct modulus; |
173 | |
174 | template<typename _Tp = void> |
175 | struct negate; |
176 | #endif |
177 | |
178 | // Ignore warnings about unary_function and binary_function. |
179 | #pragma GCC diagnostic push |
180 | #pragma GCC diagnostic ignored "-Wdeprecated-declarations" |
181 | |
182 | /// One of the @link arithmetic_functors math functors@endlink. |
183 | template<typename _Tp> |
184 | struct plus : public binary_function<_Tp, _Tp, _Tp> |
185 | { |
186 | /// Returns the sum |
187 | _GLIBCXX14_CONSTEXPR |
188 | _Tp |
189 | operator()(const _Tp& __x, const _Tp& __y) const |
190 | { return __x + __y; } |
191 | }; |
192 | |
193 | /// One of the @link arithmetic_functors math functors@endlink. |
194 | template<typename _Tp> |
195 | struct minus : public binary_function<_Tp, _Tp, _Tp> |
196 | { |
197 | _GLIBCXX14_CONSTEXPR |
198 | _Tp |
199 | operator()(const _Tp& __x, const _Tp& __y) const |
200 | { return __x - __y; } |
201 | }; |
202 | |
203 | /// One of the @link arithmetic_functors math functors@endlink. |
204 | template<typename _Tp> |
205 | struct multiplies : public binary_function<_Tp, _Tp, _Tp> |
206 | { |
207 | _GLIBCXX14_CONSTEXPR |
208 | _Tp |
209 | operator()(const _Tp& __x, const _Tp& __y) const |
210 | { return __x * __y; } |
211 | }; |
212 | |
213 | /// One of the @link arithmetic_functors math functors@endlink. |
214 | template<typename _Tp> |
215 | struct divides : public binary_function<_Tp, _Tp, _Tp> |
216 | { |
217 | _GLIBCXX14_CONSTEXPR |
218 | _Tp |
219 | operator()(const _Tp& __x, const _Tp& __y) const |
220 | { return __x / __y; } |
221 | }; |
222 | |
223 | /// One of the @link arithmetic_functors math functors@endlink. |
224 | template<typename _Tp> |
225 | struct modulus : public binary_function<_Tp, _Tp, _Tp> |
226 | { |
227 | _GLIBCXX14_CONSTEXPR |
228 | _Tp |
229 | operator()(const _Tp& __x, const _Tp& __y) const |
230 | { return __x % __y; } |
231 | }; |
232 | |
233 | /// One of the @link arithmetic_functors math functors@endlink. |
234 | template<typename _Tp> |
235 | struct negate : public unary_function<_Tp, _Tp> |
236 | { |
237 | _GLIBCXX14_CONSTEXPR |
238 | _Tp |
239 | operator()(const _Tp& __x) const |
240 | { return -__x; } |
241 | }; |
242 | #pragma GCC diagnostic pop |
243 | |
244 | #ifdef __glibcxx_transparent_operators // C++ >= 14 |
245 | template<> |
246 | struct plus<void> |
247 | { |
248 | template <typename _Tp, typename _Up> |
249 | _GLIBCXX14_CONSTEXPR |
250 | auto |
251 | operator()(_Tp&& __t, _Up&& __u) const |
252 | noexcept(noexcept(std::forward<_Tp>(__t) + std::forward<_Up>(__u))) |
253 | -> decltype(std::forward<_Tp>(__t) + std::forward<_Up>(__u)) |
254 | { return std::forward<_Tp>(__t) + std::forward<_Up>(__u); } |
255 | |
256 | typedef __is_transparent is_transparent; |
257 | }; |
258 | |
259 | /// One of the @link arithmetic_functors math functors@endlink. |
260 | template<> |
261 | struct minus<void> |
262 | { |
263 | template <typename _Tp, typename _Up> |
264 | _GLIBCXX14_CONSTEXPR |
265 | auto |
266 | operator()(_Tp&& __t, _Up&& __u) const |
267 | noexcept(noexcept(std::forward<_Tp>(__t) - std::forward<_Up>(__u))) |
268 | -> decltype(std::forward<_Tp>(__t) - std::forward<_Up>(__u)) |
269 | { return std::forward<_Tp>(__t) - std::forward<_Up>(__u); } |
270 | |
271 | typedef __is_transparent is_transparent; |
272 | }; |
273 | |
274 | /// One of the @link arithmetic_functors math functors@endlink. |
275 | template<> |
276 | struct multiplies<void> |
277 | { |
278 | template <typename _Tp, typename _Up> |
279 | _GLIBCXX14_CONSTEXPR |
280 | auto |
281 | operator()(_Tp&& __t, _Up&& __u) const |
282 | noexcept(noexcept(std::forward<_Tp>(__t) * std::forward<_Up>(__u))) |
283 | -> decltype(std::forward<_Tp>(__t) * std::forward<_Up>(__u)) |
284 | { return std::forward<_Tp>(__t) * std::forward<_Up>(__u); } |
285 | |
286 | typedef __is_transparent is_transparent; |
287 | }; |
288 | |
289 | /// One of the @link arithmetic_functors math functors@endlink. |
290 | template<> |
291 | struct divides<void> |
292 | { |
293 | template <typename _Tp, typename _Up> |
294 | _GLIBCXX14_CONSTEXPR |
295 | auto |
296 | operator()(_Tp&& __t, _Up&& __u) const |
297 | noexcept(noexcept(std::forward<_Tp>(__t) / std::forward<_Up>(__u))) |
298 | -> decltype(std::forward<_Tp>(__t) / std::forward<_Up>(__u)) |
299 | { return std::forward<_Tp>(__t) / std::forward<_Up>(__u); } |
300 | |
301 | typedef __is_transparent is_transparent; |
302 | }; |
303 | |
304 | /// One of the @link arithmetic_functors math functors@endlink. |
305 | template<> |
306 | struct modulus<void> |
307 | { |
308 | template <typename _Tp, typename _Up> |
309 | _GLIBCXX14_CONSTEXPR |
310 | auto |
311 | operator()(_Tp&& __t, _Up&& __u) const |
312 | noexcept(noexcept(std::forward<_Tp>(__t) % std::forward<_Up>(__u))) |
313 | -> decltype(std::forward<_Tp>(__t) % std::forward<_Up>(__u)) |
314 | { return std::forward<_Tp>(__t) % std::forward<_Up>(__u); } |
315 | |
316 | typedef __is_transparent is_transparent; |
317 | }; |
318 | |
319 | /// One of the @link arithmetic_functors math functors@endlink. |
320 | template<> |
321 | struct negate<void> |
322 | { |
323 | template <typename _Tp> |
324 | _GLIBCXX14_CONSTEXPR |
325 | auto |
326 | operator()(_Tp&& __t) const |
327 | noexcept(noexcept(-std::forward<_Tp>(__t))) |
328 | -> decltype(-std::forward<_Tp>(__t)) |
329 | { return -std::forward<_Tp>(__t); } |
330 | |
331 | typedef __is_transparent is_transparent; |
332 | }; |
333 | #endif |
334 | /** @} */ |
335 | |
336 | // 20.3.3 comparisons |
337 | /** @defgroup comparison_functors Comparison Classes |
338 | * @ingroup functors |
339 | * |
340 | * The library provides six wrapper functors for all the basic comparisons |
341 | * in C++, like @c <. |
342 | * |
343 | * @{ |
344 | */ |
345 | #if __glibcxx_transparent_operators // C++ >= 14 |
346 | template<typename _Tp = void> |
347 | struct equal_to; |
348 | |
349 | template<typename _Tp = void> |
350 | struct not_equal_to; |
351 | |
352 | template<typename _Tp = void> |
353 | struct greater; |
354 | |
355 | template<typename _Tp = void> |
356 | struct less; |
357 | |
358 | template<typename _Tp = void> |
359 | struct greater_equal; |
360 | |
361 | template<typename _Tp = void> |
362 | struct less_equal; |
363 | #endif |
364 | |
365 | #pragma GCC diagnostic push |
366 | #pragma GCC diagnostic ignored "-Wdeprecated-declarations" |
367 | |
368 | /// One of the @link comparison_functors comparison functors@endlink. |
369 | template<typename _Tp> |
370 | struct equal_to : public binary_function<_Tp, _Tp, bool> |
371 | { |
372 | _GLIBCXX14_CONSTEXPR |
373 | bool |
374 | operator()(const _Tp& __x, const _Tp& __y) const |
375 | { return __x == __y; } |
376 | }; |
377 | |
378 | /// One of the @link comparison_functors comparison functors@endlink. |
379 | template<typename _Tp> |
380 | struct not_equal_to : public binary_function<_Tp, _Tp, bool> |
381 | { |
382 | _GLIBCXX14_CONSTEXPR |
383 | bool |
384 | operator()(const _Tp& __x, const _Tp& __y) const |
385 | { return __x != __y; } |
386 | }; |
387 | |
388 | /// One of the @link comparison_functors comparison functors@endlink. |
389 | template<typename _Tp> |
390 | struct greater : public binary_function<_Tp, _Tp, bool> |
391 | { |
392 | _GLIBCXX14_CONSTEXPR |
393 | bool |
394 | operator()(const _Tp& __x, const _Tp& __y) const |
395 | { return __x > __y; } |
396 | }; |
397 | |
398 | /// One of the @link comparison_functors comparison functors@endlink. |
399 | template<typename _Tp> |
400 | struct less : public binary_function<_Tp, _Tp, bool> |
401 | { |
402 | _GLIBCXX14_CONSTEXPR |
403 | bool |
404 | operator()(const _Tp& __x, const _Tp& __y) const |
405 | { return __x < __y; } |
406 | }; |
407 | |
408 | /// One of the @link comparison_functors comparison functors@endlink. |
409 | template<typename _Tp> |
410 | struct greater_equal : public binary_function<_Tp, _Tp, bool> |
411 | { |
412 | _GLIBCXX14_CONSTEXPR |
413 | bool |
414 | operator()(const _Tp& __x, const _Tp& __y) const |
415 | { return __x >= __y; } |
416 | }; |
417 | |
418 | /// One of the @link comparison_functors comparison functors@endlink. |
419 | template<typename _Tp> |
420 | struct less_equal : public binary_function<_Tp, _Tp, bool> |
421 | { |
422 | _GLIBCXX14_CONSTEXPR |
423 | bool |
424 | operator()(const _Tp& __x, const _Tp& __y) const |
425 | { return __x <= __y; } |
426 | }; |
427 | |
428 | // Partial specialization of std::greater for pointers. |
429 | template<typename _Tp> |
430 | struct greater<_Tp*> : public binary_function<_Tp*, _Tp*, bool> |
431 | { |
432 | _GLIBCXX14_CONSTEXPR bool |
433 | operator()(_Tp* __x, _Tp* __y) const _GLIBCXX_NOTHROW |
434 | { |
435 | #if __cplusplus >= 201402L |
436 | if (std::__is_constant_evaluated()) |
437 | return __x > __y; |
438 | #endif |
439 | return (__UINTPTR_TYPE__)__x > (__UINTPTR_TYPE__)__y; |
440 | } |
441 | }; |
442 | |
443 | // Partial specialization of std::less for pointers. |
444 | template<typename _Tp> |
445 | struct less<_Tp*> : public binary_function<_Tp*, _Tp*, bool> |
446 | { |
447 | _GLIBCXX14_CONSTEXPR bool |
448 | operator()(_Tp* __x, _Tp* __y) const _GLIBCXX_NOTHROW |
449 | { |
450 | #if __cplusplus >= 201402L |
451 | if (std::__is_constant_evaluated()) |
452 | return __x < __y; |
453 | #endif |
454 | return (__UINTPTR_TYPE__)__x < (__UINTPTR_TYPE__)__y; |
455 | } |
456 | }; |
457 | |
458 | // Partial specialization of std::greater_equal for pointers. |
459 | template<typename _Tp> |
460 | struct greater_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool> |
461 | { |
462 | _GLIBCXX14_CONSTEXPR bool |
463 | operator()(_Tp* __x, _Tp* __y) const _GLIBCXX_NOTHROW |
464 | { |
465 | #if __cplusplus >= 201402L |
466 | if (std::__is_constant_evaluated()) |
467 | return __x >= __y; |
468 | #endif |
469 | return (__UINTPTR_TYPE__)__x >= (__UINTPTR_TYPE__)__y; |
470 | } |
471 | }; |
472 | |
473 | // Partial specialization of std::less_equal for pointers. |
474 | template<typename _Tp> |
475 | struct less_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool> |
476 | { |
477 | _GLIBCXX14_CONSTEXPR bool |
478 | operator()(_Tp* __x, _Tp* __y) const _GLIBCXX_NOTHROW |
479 | { |
480 | #if __cplusplus >= 201402L |
481 | if (std::__is_constant_evaluated()) |
482 | return __x <= __y; |
483 | #endif |
484 | return (__UINTPTR_TYPE__)__x <= (__UINTPTR_TYPE__)__y; |
485 | } |
486 | }; |
487 | #pragma GCC diagnostic pop |
488 | |
489 | #ifdef __glibcxx_transparent_operators // C++ >= 14 |
490 | /// One of the @link comparison_functors comparison functors@endlink. |
491 | template<> |
492 | struct equal_to<void> |
493 | { |
494 | template <typename _Tp, typename _Up> |
495 | constexpr auto |
496 | operator()(_Tp&& __t, _Up&& __u) const |
497 | noexcept(noexcept(std::forward<_Tp>(__t) == std::forward<_Up>(__u))) |
498 | -> decltype(std::forward<_Tp>(__t) == std::forward<_Up>(__u)) |
499 | { return std::forward<_Tp>(__t) == std::forward<_Up>(__u); } |
500 | |
501 | typedef __is_transparent is_transparent; |
502 | }; |
503 | |
504 | /// One of the @link comparison_functors comparison functors@endlink. |
505 | template<> |
506 | struct not_equal_to<void> |
507 | { |
508 | template <typename _Tp, typename _Up> |
509 | constexpr auto |
510 | operator()(_Tp&& __t, _Up&& __u) const |
511 | noexcept(noexcept(std::forward<_Tp>(__t) != std::forward<_Up>(__u))) |
512 | -> decltype(std::forward<_Tp>(__t) != std::forward<_Up>(__u)) |
513 | { return std::forward<_Tp>(__t) != std::forward<_Up>(__u); } |
514 | |
515 | typedef __is_transparent is_transparent; |
516 | }; |
517 | |
518 | /// One of the @link comparison_functors comparison functors@endlink. |
519 | template<> |
520 | struct greater<void> |
521 | { |
522 | template <typename _Tp, typename _Up> |
523 | constexpr auto |
524 | operator()(_Tp&& __t, _Up&& __u) const |
525 | noexcept(noexcept(std::forward<_Tp>(__t) > std::forward<_Up>(__u))) |
526 | -> decltype(std::forward<_Tp>(__t) > std::forward<_Up>(__u)) |
527 | { |
528 | return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), |
529 | __ptr_cmp<_Tp, _Up>{}); |
530 | } |
531 | |
532 | template<typename _Tp, typename _Up> |
533 | constexpr bool |
534 | operator()(_Tp* __t, _Up* __u) const noexcept |
535 | { return greater<common_type_t<_Tp*, _Up*>>{}(__t, __u); } |
536 | |
537 | typedef __is_transparent is_transparent; |
538 | |
539 | private: |
540 | template <typename _Tp, typename _Up> |
541 | static constexpr decltype(auto) |
542 | _S_cmp(_Tp&& __t, _Up&& __u, false_type) |
543 | { return std::forward<_Tp>(__t) > std::forward<_Up>(__u); } |
544 | |
545 | template <typename _Tp, typename _Up> |
546 | static constexpr bool |
547 | _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept |
548 | { |
549 | return greater<const volatile void*>{}( |
550 | static_cast<const volatile void*>(std::forward<_Tp>(__t)), |
551 | static_cast<const volatile void*>(std::forward<_Up>(__u))); |
552 | } |
553 | |
554 | // True if there is no viable operator> member function. |
555 | template<typename _Tp, typename _Up, typename = void> |
556 | struct __not_overloaded2 : true_type { }; |
557 | |
558 | // False if we can call T.operator>(U) |
559 | template<typename _Tp, typename _Up> |
560 | struct __not_overloaded2<_Tp, _Up, __void_t< |
561 | decltype(std::declval<_Tp>().operator>(std::declval<_Up>()))>> |
562 | : false_type { }; |
563 | |
564 | // True if there is no overloaded operator> for these operands. |
565 | template<typename _Tp, typename _Up, typename = void> |
566 | struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; |
567 | |
568 | // False if we can call operator>(T,U) |
569 | template<typename _Tp, typename _Up> |
570 | struct __not_overloaded<_Tp, _Up, __void_t< |
571 | decltype(operator>(std::declval<_Tp>(), std::declval<_Up>()))>> |
572 | : false_type { }; |
573 | |
574 | template<typename _Tp, typename _Up> |
575 | using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, |
576 | is_convertible<_Tp, const volatile void*>, |
577 | is_convertible<_Up, const volatile void*>>; |
578 | }; |
579 | |
580 | /// One of the @link comparison_functors comparison functors@endlink. |
581 | template<> |
582 | struct less<void> |
583 | { |
584 | template <typename _Tp, typename _Up> |
585 | constexpr auto |
586 | operator()(_Tp&& __t, _Up&& __u) const |
587 | noexcept(noexcept(std::forward<_Tp>(__t) < std::forward<_Up>(__u))) |
588 | -> decltype(std::forward<_Tp>(__t) < std::forward<_Up>(__u)) |
589 | { |
590 | return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), |
591 | __ptr_cmp<_Tp, _Up>{}); |
592 | } |
593 | |
594 | template<typename _Tp, typename _Up> |
595 | constexpr bool |
596 | operator()(_Tp* __t, _Up* __u) const noexcept |
597 | { return less<common_type_t<_Tp*, _Up*>>{}(__t, __u); } |
598 | |
599 | typedef __is_transparent is_transparent; |
600 | |
601 | private: |
602 | template <typename _Tp, typename _Up> |
603 | static constexpr decltype(auto) |
604 | _S_cmp(_Tp&& __t, _Up&& __u, false_type) |
605 | { return std::forward<_Tp>(__t) < std::forward<_Up>(__u); } |
606 | |
607 | template <typename _Tp, typename _Up> |
608 | static constexpr bool |
609 | _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept |
610 | { |
611 | return less<const volatile void*>{}( |
612 | static_cast<const volatile void*>(std::forward<_Tp>(__t)), |
613 | static_cast<const volatile void*>(std::forward<_Up>(__u))); |
614 | } |
615 | |
616 | // True if there is no viable operator< member function. |
617 | template<typename _Tp, typename _Up, typename = void> |
618 | struct __not_overloaded2 : true_type { }; |
619 | |
620 | // False if we can call T.operator<(U) |
621 | template<typename _Tp, typename _Up> |
622 | struct __not_overloaded2<_Tp, _Up, __void_t< |
623 | decltype(std::declval<_Tp>().operator<(std::declval<_Up>()))>> |
624 | : false_type { }; |
625 | |
626 | // True if there is no overloaded operator< for these operands. |
627 | template<typename _Tp, typename _Up, typename = void> |
628 | struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; |
629 | |
630 | // False if we can call operator<(T,U) |
631 | template<typename _Tp, typename _Up> |
632 | struct __not_overloaded<_Tp, _Up, __void_t< |
633 | decltype(operator<(std::declval<_Tp>(), std::declval<_Up>()))>> |
634 | : false_type { }; |
635 | |
636 | template<typename _Tp, typename _Up> |
637 | using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, |
638 | is_convertible<_Tp, const volatile void*>, |
639 | is_convertible<_Up, const volatile void*>>; |
640 | }; |
641 | |
642 | /// One of the @link comparison_functors comparison functors@endlink. |
643 | template<> |
644 | struct greater_equal<void> |
645 | { |
646 | template <typename _Tp, typename _Up> |
647 | constexpr auto |
648 | operator()(_Tp&& __t, _Up&& __u) const |
649 | noexcept(noexcept(std::forward<_Tp>(__t) >= std::forward<_Up>(__u))) |
650 | -> decltype(std::forward<_Tp>(__t) >= std::forward<_Up>(__u)) |
651 | { |
652 | return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), |
653 | __ptr_cmp<_Tp, _Up>{}); |
654 | } |
655 | |
656 | template<typename _Tp, typename _Up> |
657 | constexpr bool |
658 | operator()(_Tp* __t, _Up* __u) const noexcept |
659 | { return greater_equal<common_type_t<_Tp*, _Up*>>{}(__t, __u); } |
660 | |
661 | typedef __is_transparent is_transparent; |
662 | |
663 | private: |
664 | template <typename _Tp, typename _Up> |
665 | static constexpr decltype(auto) |
666 | _S_cmp(_Tp&& __t, _Up&& __u, false_type) |
667 | { return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); } |
668 | |
669 | template <typename _Tp, typename _Up> |
670 | static constexpr bool |
671 | _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept |
672 | { |
673 | return greater_equal<const volatile void*>{}( |
674 | static_cast<const volatile void*>(std::forward<_Tp>(__t)), |
675 | static_cast<const volatile void*>(std::forward<_Up>(__u))); |
676 | } |
677 | |
678 | // True if there is no viable operator>= member function. |
679 | template<typename _Tp, typename _Up, typename = void> |
680 | struct __not_overloaded2 : true_type { }; |
681 | |
682 | // False if we can call T.operator>=(U) |
683 | template<typename _Tp, typename _Up> |
684 | struct __not_overloaded2<_Tp, _Up, __void_t< |
685 | decltype(std::declval<_Tp>().operator>=(std::declval<_Up>()))>> |
686 | : false_type { }; |
687 | |
688 | // True if there is no overloaded operator>= for these operands. |
689 | template<typename _Tp, typename _Up, typename = void> |
690 | struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; |
691 | |
692 | // False if we can call operator>=(T,U) |
693 | template<typename _Tp, typename _Up> |
694 | struct __not_overloaded<_Tp, _Up, __void_t< |
695 | decltype(operator>=(std::declval<_Tp>(), std::declval<_Up>()))>> |
696 | : false_type { }; |
697 | |
698 | template<typename _Tp, typename _Up> |
699 | using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, |
700 | is_convertible<_Tp, const volatile void*>, |
701 | is_convertible<_Up, const volatile void*>>; |
702 | }; |
703 | |
704 | /// One of the @link comparison_functors comparison functors@endlink. |
705 | template<> |
706 | struct less_equal<void> |
707 | { |
708 | template <typename _Tp, typename _Up> |
709 | constexpr auto |
710 | operator()(_Tp&& __t, _Up&& __u) const |
711 | noexcept(noexcept(std::forward<_Tp>(__t) <= std::forward<_Up>(__u))) |
712 | -> decltype(std::forward<_Tp>(__t) <= std::forward<_Up>(__u)) |
713 | { |
714 | return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), |
715 | __ptr_cmp<_Tp, _Up>{}); |
716 | } |
717 | |
718 | template<typename _Tp, typename _Up> |
719 | constexpr bool |
720 | operator()(_Tp* __t, _Up* __u) const noexcept |
721 | { return less_equal<common_type_t<_Tp*, _Up*>>{}(__t, __u); } |
722 | |
723 | typedef __is_transparent is_transparent; |
724 | |
725 | private: |
726 | template <typename _Tp, typename _Up> |
727 | static constexpr decltype(auto) |
728 | _S_cmp(_Tp&& __t, _Up&& __u, false_type) |
729 | { return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); } |
730 | |
731 | template <typename _Tp, typename _Up> |
732 | static constexpr bool |
733 | _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept |
734 | { |
735 | return less_equal<const volatile void*>{}( |
736 | static_cast<const volatile void*>(std::forward<_Tp>(__t)), |
737 | static_cast<const volatile void*>(std::forward<_Up>(__u))); |
738 | } |
739 | |
740 | // True if there is no viable operator<= member function. |
741 | template<typename _Tp, typename _Up, typename = void> |
742 | struct __not_overloaded2 : true_type { }; |
743 | |
744 | // False if we can call T.operator<=(U) |
745 | template<typename _Tp, typename _Up> |
746 | struct __not_overloaded2<_Tp, _Up, __void_t< |
747 | decltype(std::declval<_Tp>().operator<=(std::declval<_Up>()))>> |
748 | : false_type { }; |
749 | |
750 | // True if there is no overloaded operator<= for these operands. |
751 | template<typename _Tp, typename _Up, typename = void> |
752 | struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; |
753 | |
754 | // False if we can call operator<=(T,U) |
755 | template<typename _Tp, typename _Up> |
756 | struct __not_overloaded<_Tp, _Up, __void_t< |
757 | decltype(operator<=(std::declval<_Tp>(), std::declval<_Up>()))>> |
758 | : false_type { }; |
759 | |
760 | template<typename _Tp, typename _Up> |
761 | using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, |
762 | is_convertible<_Tp, const volatile void*>, |
763 | is_convertible<_Up, const volatile void*>>; |
764 | }; |
765 | #endif // __glibcxx_transparent_operators |
766 | /** @} */ |
767 | |
768 | // 20.3.4 logical operations |
769 | /** @defgroup logical_functors Boolean Operations Classes |
770 | * @ingroup functors |
771 | * |
772 | * The library provides function objects for the logical operations: |
773 | * `&&`, `||`, and `!`. |
774 | * |
775 | * @{ |
776 | */ |
777 | #ifdef __glibcxx_transparent_operators // C++ >= 14 |
778 | template<typename _Tp = void> |
779 | struct logical_and; |
780 | |
781 | template<typename _Tp = void> |
782 | struct logical_or; |
783 | |
784 | template<typename _Tp = void> |
785 | struct logical_not; |
786 | #endif |
787 | |
788 | #pragma GCC diagnostic push |
789 | #pragma GCC diagnostic ignored "-Wdeprecated-declarations" |
790 | |
791 | /// One of the @link logical_functors Boolean operations functors@endlink. |
792 | template<typename _Tp> |
793 | struct logical_and : public binary_function<_Tp, _Tp, bool> |
794 | { |
795 | _GLIBCXX14_CONSTEXPR |
796 | bool |
797 | operator()(const _Tp& __x, const _Tp& __y) const |
798 | { return __x && __y; } |
799 | }; |
800 | |
801 | /// One of the @link logical_functors Boolean operations functors@endlink. |
802 | template<typename _Tp> |
803 | struct logical_or : public binary_function<_Tp, _Tp, bool> |
804 | { |
805 | _GLIBCXX14_CONSTEXPR |
806 | bool |
807 | operator()(const _Tp& __x, const _Tp& __y) const |
808 | { return __x || __y; } |
809 | }; |
810 | |
811 | /// One of the @link logical_functors Boolean operations functors@endlink. |
812 | template<typename _Tp> |
813 | struct logical_not : public unary_function<_Tp, bool> |
814 | { |
815 | _GLIBCXX14_CONSTEXPR |
816 | bool |
817 | operator()(const _Tp& __x) const |
818 | { return !__x; } |
819 | }; |
820 | #pragma GCC diagnostic pop |
821 | |
822 | #ifdef __glibcxx_transparent_operators // C++ >= 14 |
823 | /// One of the @link logical_functors Boolean operations functors@endlink. |
824 | template<> |
825 | struct logical_and<void> |
826 | { |
827 | template <typename _Tp, typename _Up> |
828 | _GLIBCXX14_CONSTEXPR |
829 | auto |
830 | operator()(_Tp&& __t, _Up&& __u) const |
831 | noexcept(noexcept(std::forward<_Tp>(__t) && std::forward<_Up>(__u))) |
832 | -> decltype(std::forward<_Tp>(__t) && std::forward<_Up>(__u)) |
833 | { return std::forward<_Tp>(__t) && std::forward<_Up>(__u); } |
834 | |
835 | typedef __is_transparent is_transparent; |
836 | }; |
837 | |
838 | /// One of the @link logical_functors Boolean operations functors@endlink. |
839 | template<> |
840 | struct logical_or<void> |
841 | { |
842 | template <typename _Tp, typename _Up> |
843 | _GLIBCXX14_CONSTEXPR |
844 | auto |
845 | operator()(_Tp&& __t, _Up&& __u) const |
846 | noexcept(noexcept(std::forward<_Tp>(__t) || std::forward<_Up>(__u))) |
847 | -> decltype(std::forward<_Tp>(__t) || std::forward<_Up>(__u)) |
848 | { return std::forward<_Tp>(__t) || std::forward<_Up>(__u); } |
849 | |
850 | typedef __is_transparent is_transparent; |
851 | }; |
852 | |
853 | /// One of the @link logical_functors Boolean operations functors@endlink. |
854 | template<> |
855 | struct logical_not<void> |
856 | { |
857 | template <typename _Tp> |
858 | _GLIBCXX14_CONSTEXPR |
859 | auto |
860 | operator()(_Tp&& __t) const |
861 | noexcept(noexcept(!std::forward<_Tp>(__t))) |
862 | -> decltype(!std::forward<_Tp>(__t)) |
863 | { return !std::forward<_Tp>(__t); } |
864 | |
865 | typedef __is_transparent is_transparent; |
866 | }; |
867 | #endif // __glibcxx_transparent_operators |
868 | /** @} */ |
869 | |
870 | #ifdef __glibcxx_transparent_operators // C++ >= 14 |
871 | template<typename _Tp = void> |
872 | struct bit_and; |
873 | |
874 | template<typename _Tp = void> |
875 | struct bit_or; |
876 | |
877 | template<typename _Tp = void> |
878 | struct bit_xor; |
879 | |
880 | template<typename _Tp = void> |
881 | struct bit_not; |
882 | #endif |
883 | |
884 | #pragma GCC diagnostic push |
885 | #pragma GCC diagnostic ignored "-Wdeprecated-declarations" |
886 | |
887 | // _GLIBCXX_RESOLVE_LIB_DEFECTS |
888 | // DR 660. Missing Bitwise Operations. |
889 | template<typename _Tp> |
890 | struct bit_and : public binary_function<_Tp, _Tp, _Tp> |
891 | { |
892 | _GLIBCXX14_CONSTEXPR |
893 | _Tp |
894 | operator()(const _Tp& __x, const _Tp& __y) const |
895 | { return __x & __y; } |
896 | }; |
897 | |
898 | template<typename _Tp> |
899 | struct bit_or : public binary_function<_Tp, _Tp, _Tp> |
900 | { |
901 | _GLIBCXX14_CONSTEXPR |
902 | _Tp |
903 | operator()(const _Tp& __x, const _Tp& __y) const |
904 | { return __x | __y; } |
905 | }; |
906 | |
907 | template<typename _Tp> |
908 | struct bit_xor : public binary_function<_Tp, _Tp, _Tp> |
909 | { |
910 | _GLIBCXX14_CONSTEXPR |
911 | _Tp |
912 | operator()(const _Tp& __x, const _Tp& __y) const |
913 | { return __x ^ __y; } |
914 | }; |
915 | |
916 | template<typename _Tp> |
917 | struct bit_not : public unary_function<_Tp, _Tp> |
918 | { |
919 | _GLIBCXX14_CONSTEXPR |
920 | _Tp |
921 | operator()(const _Tp& __x) const |
922 | { return ~__x; } |
923 | }; |
924 | #pragma GCC diagnostic pop |
925 | |
926 | #ifdef __glibcxx_transparent_operators // C++ >= 14 |
927 | template <> |
928 | struct bit_and<void> |
929 | { |
930 | template <typename _Tp, typename _Up> |
931 | _GLIBCXX14_CONSTEXPR |
932 | auto |
933 | operator()(_Tp&& __t, _Up&& __u) const |
934 | noexcept(noexcept(std::forward<_Tp>(__t) & std::forward<_Up>(__u))) |
935 | -> decltype(std::forward<_Tp>(__t) & std::forward<_Up>(__u)) |
936 | { return std::forward<_Tp>(__t) & std::forward<_Up>(__u); } |
937 | |
938 | typedef __is_transparent is_transparent; |
939 | }; |
940 | |
941 | template <> |
942 | struct bit_or<void> |
943 | { |
944 | template <typename _Tp, typename _Up> |
945 | _GLIBCXX14_CONSTEXPR |
946 | auto |
947 | operator()(_Tp&& __t, _Up&& __u) const |
948 | noexcept(noexcept(std::forward<_Tp>(__t) | std::forward<_Up>(__u))) |
949 | -> decltype(std::forward<_Tp>(__t) | std::forward<_Up>(__u)) |
950 | { return std::forward<_Tp>(__t) | std::forward<_Up>(__u); } |
951 | |
952 | typedef __is_transparent is_transparent; |
953 | }; |
954 | |
955 | template <> |
956 | struct bit_xor<void> |
957 | { |
958 | template <typename _Tp, typename _Up> |
959 | _GLIBCXX14_CONSTEXPR |
960 | auto |
961 | operator()(_Tp&& __t, _Up&& __u) const |
962 | noexcept(noexcept(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u))) |
963 | -> decltype(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u)) |
964 | { return std::forward<_Tp>(__t) ^ std::forward<_Up>(__u); } |
965 | |
966 | typedef __is_transparent is_transparent; |
967 | }; |
968 | |
969 | template <> |
970 | struct bit_not<void> |
971 | { |
972 | template <typename _Tp> |
973 | _GLIBCXX14_CONSTEXPR |
974 | auto |
975 | operator()(_Tp&& __t) const |
976 | noexcept(noexcept(~std::forward<_Tp>(__t))) |
977 | -> decltype(~std::forward<_Tp>(__t)) |
978 | { return ~std::forward<_Tp>(__t); } |
979 | |
980 | typedef __is_transparent is_transparent; |
981 | }; |
982 | #endif // C++14 |
983 | |
984 | #pragma GCC diagnostic push |
985 | #pragma GCC diagnostic ignored "-Wdeprecated-declarations" |
986 | |
987 | // 20.3.5 negators |
988 | /** @defgroup negators Negators |
989 | * @ingroup functors |
990 | * |
991 | * The function templates `not1` and `not2` are function object adaptors, |
992 | * which each take a predicate functor and wrap it in an instance of |
993 | * `unary_negate` or `binary_negate`, respectively. Those classes are |
994 | * functors whose `operator()` evaluates the wrapped predicate function |
995 | * and then returns the negation of the result. |
996 | * |
997 | * For example, given a vector of integers and a trivial predicate, |
998 | * \code |
999 | * struct IntGreaterThanThree |
1000 | * : public std::unary_function<int, bool> |
1001 | * { |
1002 | * bool operator() (int x) const { return x > 3; } |
1003 | * }; |
1004 | * |
1005 | * std::find_if (v.begin(), v.end(), not1(IntGreaterThanThree())); |
1006 | * \endcode |
1007 | * The call to `find_if` will locate the first index (i) of `v` for which |
1008 | * `!(v[i] > 3)` is true. |
1009 | * |
1010 | * The not1/unary_negate combination works on predicates taking a single |
1011 | * argument. The not2/binary_negate combination works on predicates taking |
1012 | * two arguments. |
1013 | * |
1014 | * @deprecated Deprecated in C++17, no longer in the standard since C++20. |
1015 | * Use `not_fn` instead. |
1016 | * |
1017 | * @{ |
1018 | */ |
1019 | /// One of the @link negators negation functors@endlink. |
1020 | template<typename _Predicate> |
1021 | class _GLIBCXX17_DEPRECATED unary_negate |
1022 | : public unary_function<typename _Predicate::argument_type, bool> |
1023 | { |
1024 | protected: |
1025 | _Predicate _M_pred; |
1026 | |
1027 | public: |
1028 | _GLIBCXX14_CONSTEXPR |
1029 | explicit |
1030 | unary_negate(const _Predicate& __x) : _M_pred(__x) { } |
1031 | |
1032 | _GLIBCXX14_CONSTEXPR |
1033 | bool |
1034 | operator()(const typename _Predicate::argument_type& __x) const |
1035 | { return !_M_pred(__x); } |
1036 | }; |
1037 | |
1038 | /// One of the @link negators negation functors@endlink. |
1039 | template<typename _Predicate> |
1040 | _GLIBCXX17_DEPRECATED_SUGGEST("std::not_fn" ) |
1041 | _GLIBCXX14_CONSTEXPR |
1042 | inline unary_negate<_Predicate> |
1043 | not1(const _Predicate& __pred) |
1044 | { return unary_negate<_Predicate>(__pred); } |
1045 | |
1046 | /// One of the @link negators negation functors@endlink. |
1047 | template<typename _Predicate> |
1048 | class _GLIBCXX17_DEPRECATED binary_negate |
1049 | : public binary_function<typename _Predicate::first_argument_type, |
1050 | typename _Predicate::second_argument_type, bool> |
1051 | { |
1052 | protected: |
1053 | _Predicate _M_pred; |
1054 | |
1055 | public: |
1056 | _GLIBCXX14_CONSTEXPR |
1057 | explicit |
1058 | binary_negate(const _Predicate& __x) : _M_pred(__x) { } |
1059 | |
1060 | _GLIBCXX14_CONSTEXPR |
1061 | bool |
1062 | operator()(const typename _Predicate::first_argument_type& __x, |
1063 | const typename _Predicate::second_argument_type& __y) const |
1064 | { return !_M_pred(__x, __y); } |
1065 | }; |
1066 | |
1067 | /// One of the @link negators negation functors@endlink. |
1068 | template<typename _Predicate> |
1069 | _GLIBCXX17_DEPRECATED_SUGGEST("std::not_fn" ) |
1070 | _GLIBCXX14_CONSTEXPR |
1071 | inline binary_negate<_Predicate> |
1072 | not2(const _Predicate& __pred) |
1073 | { return binary_negate<_Predicate>(__pred); } |
1074 | /** @} */ |
1075 | |
1076 | // 20.3.7 adaptors pointers functions |
1077 | /** @defgroup pointer_adaptors Adaptors for pointers to functions |
1078 | * @ingroup functors |
1079 | * |
1080 | * The advantage of function objects over pointers to functions is that |
1081 | * the objects in the standard library declare nested typedefs describing |
1082 | * their argument and result types with uniform names (e.g., `result_type` |
1083 | * from the base classes `unary_function` and `binary_function`). |
1084 | * Sometimes those typedefs are required, not just optional. |
1085 | * |
1086 | * Adaptors are provided to turn pointers to unary (single-argument) and |
1087 | * binary (double-argument) functions into function objects. The |
1088 | * long-winded functor `pointer_to_unary_function` is constructed with a |
1089 | * function pointer `f`, and its `operator()` called with argument `x` |
1090 | * returns `f(x)`. The functor `pointer_to_binary_function` does the same |
1091 | * thing, but with a double-argument `f` and `operator()`. |
1092 | * |
1093 | * The function `ptr_fun` takes a pointer-to-function `f` and constructs |
1094 | * an instance of the appropriate functor. |
1095 | * |
1096 | * @deprecated Deprecated in C++11, no longer in the standard since C++17. |
1097 | * |
1098 | * @{ |
1099 | */ |
1100 | /// One of the @link pointer_adaptors adaptors for function pointers@endlink. |
1101 | template<typename _Arg, typename _Result> |
1102 | class pointer_to_unary_function : public unary_function<_Arg, _Result> |
1103 | { |
1104 | protected: |
1105 | _Result (*_M_ptr)(_Arg); |
1106 | |
1107 | public: |
1108 | pointer_to_unary_function() { } |
1109 | |
1110 | explicit |
1111 | pointer_to_unary_function(_Result (*__x)(_Arg)) |
1112 | : _M_ptr(__x) { } |
1113 | |
1114 | _Result |
1115 | operator()(_Arg __x) const |
1116 | { return _M_ptr(__x); } |
1117 | } _GLIBCXX11_DEPRECATED; |
1118 | |
1119 | /// One of the @link pointer_adaptors adaptors for function pointers@endlink. |
1120 | template<typename _Arg, typename _Result> |
1121 | _GLIBCXX11_DEPRECATED_SUGGEST("std::function" ) |
1122 | inline pointer_to_unary_function<_Arg, _Result> |
1123 | ptr_fun(_Result (*__x)(_Arg)) |
1124 | { return pointer_to_unary_function<_Arg, _Result>(__x); } |
1125 | |
1126 | /// One of the @link pointer_adaptors adaptors for function pointers@endlink. |
1127 | template<typename _Arg1, typename _Arg2, typename _Result> |
1128 | class pointer_to_binary_function |
1129 | : public binary_function<_Arg1, _Arg2, _Result> |
1130 | { |
1131 | protected: |
1132 | _Result (*_M_ptr)(_Arg1, _Arg2); |
1133 | |
1134 | public: |
1135 | pointer_to_binary_function() { } |
1136 | |
1137 | explicit |
1138 | pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2)) |
1139 | : _M_ptr(__x) { } |
1140 | |
1141 | _Result |
1142 | operator()(_Arg1 __x, _Arg2 __y) const |
1143 | { return _M_ptr(__x, __y); } |
1144 | } _GLIBCXX11_DEPRECATED; |
1145 | |
1146 | /// One of the @link pointer_adaptors adaptors for function pointers@endlink. |
1147 | template<typename _Arg1, typename _Arg2, typename _Result> |
1148 | _GLIBCXX11_DEPRECATED_SUGGEST("std::function" ) |
1149 | inline pointer_to_binary_function<_Arg1, _Arg2, _Result> |
1150 | ptr_fun(_Result (*__x)(_Arg1, _Arg2)) |
1151 | { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); } |
1152 | /** @} */ |
1153 | |
1154 | template<typename _Tp> |
1155 | struct _Identity |
1156 | : public unary_function<_Tp, _Tp> |
1157 | { |
1158 | _Tp& |
1159 | operator()(_Tp& __x) const |
1160 | { return __x; } |
1161 | |
1162 | const _Tp& |
1163 | operator()(const _Tp& __x) const |
1164 | { return __x; } |
1165 | }; |
1166 | |
1167 | // Partial specialization, avoids confusing errors in e.g. std::set<const T>. |
1168 | template<typename _Tp> struct _Identity<const _Tp> : _Identity<_Tp> { }; |
1169 | |
1170 | template<typename _Pair> |
1171 | struct _Select1st |
1172 | : public unary_function<_Pair, typename _Pair::first_type> |
1173 | { |
1174 | typename _Pair::first_type& |
1175 | operator()(_Pair& __x) const |
1176 | { return __x.first; } |
1177 | |
1178 | const typename _Pair::first_type& |
1179 | operator()(const _Pair& __x) const |
1180 | { return __x.first; } |
1181 | |
1182 | #if __cplusplus >= 201103L |
1183 | template<typename _Pair2> |
1184 | typename _Pair2::first_type& |
1185 | operator()(_Pair2& __x) const |
1186 | { return __x.first; } |
1187 | |
1188 | template<typename _Pair2> |
1189 | const typename _Pair2::first_type& |
1190 | operator()(const _Pair2& __x) const |
1191 | { return __x.first; } |
1192 | #endif |
1193 | }; |
1194 | |
1195 | template<typename _Pair> |
1196 | struct _Select2nd |
1197 | : public unary_function<_Pair, typename _Pair::second_type> |
1198 | { |
1199 | typename _Pair::second_type& |
1200 | operator()(_Pair& __x) const |
1201 | { return __x.second; } |
1202 | |
1203 | const typename _Pair::second_type& |
1204 | operator()(const _Pair& __x) const |
1205 | { return __x.second; } |
1206 | }; |
1207 | |
1208 | // 20.3.8 adaptors pointers members |
1209 | /** @defgroup ptrmem_adaptors Adaptors for pointers to members |
1210 | * @ingroup functors |
1211 | * |
1212 | * There are a total of 8 = 2^3 function objects in this family. |
1213 | * (1) Member functions taking no arguments vs member functions taking |
1214 | * one argument. |
1215 | * (2) Call through pointer vs call through reference. |
1216 | * (3) Const vs non-const member function. |
1217 | * |
1218 | * All of this complexity is in the function objects themselves. You can |
1219 | * ignore it by using the helper function `mem_fun` and `mem_fun_ref`, |
1220 | * which create whichever type of adaptor is appropriate. |
1221 | * |
1222 | * @deprecated Deprecated in C++11, no longer in the standard since C++17. |
1223 | * Use `mem_fn` instead. |
1224 | * |
1225 | * @{ |
1226 | */ |
1227 | /// One of the @link ptrmem_adaptors adaptors for member pointers@endlink. |
1228 | template<typename _Ret, typename _Tp> |
1229 | class mem_fun_t : public unary_function<_Tp*, _Ret> |
1230 | { |
1231 | public: |
1232 | explicit |
1233 | mem_fun_t(_Ret (_Tp::*__pf)()) |
1234 | : _M_f(__pf) { } |
1235 | |
1236 | _Ret |
1237 | operator()(_Tp* __p) const |
1238 | { return (__p->*_M_f)(); } |
1239 | |
1240 | private: |
1241 | _Ret (_Tp::*_M_f)(); |
1242 | } _GLIBCXX11_DEPRECATED; |
1243 | |
1244 | /// One of the @link ptrmem_adaptors adaptors for member pointers@endlink. |
1245 | template<typename _Ret, typename _Tp> |
1246 | class const_mem_fun_t : public unary_function<const _Tp*, _Ret> |
1247 | { |
1248 | public: |
1249 | explicit |
1250 | const_mem_fun_t(_Ret (_Tp::*__pf)() const) |
1251 | : _M_f(__pf) { } |
1252 | |
1253 | _Ret |
1254 | operator()(const _Tp* __p) const |
1255 | { return (__p->*_M_f)(); } |
1256 | |
1257 | private: |
1258 | _Ret (_Tp::*_M_f)() const; |
1259 | } _GLIBCXX11_DEPRECATED; |
1260 | |
1261 | /// One of the @link ptrmem_adaptors adaptors for member pointers@endlink. |
1262 | template<typename _Ret, typename _Tp> |
1263 | class mem_fun_ref_t : public unary_function<_Tp, _Ret> |
1264 | { |
1265 | public: |
1266 | explicit |
1267 | mem_fun_ref_t(_Ret (_Tp::*__pf)()) |
1268 | : _M_f(__pf) { } |
1269 | |
1270 | _Ret |
1271 | operator()(_Tp& __r) const |
1272 | { return (__r.*_M_f)(); } |
1273 | |
1274 | private: |
1275 | _Ret (_Tp::*_M_f)(); |
1276 | } _GLIBCXX11_DEPRECATED; |
1277 | |
1278 | /// One of the @link ptrmem_adaptors adaptors for member pointers@endlink. |
1279 | template<typename _Ret, typename _Tp> |
1280 | class const_mem_fun_ref_t : public unary_function<_Tp, _Ret> |
1281 | { |
1282 | public: |
1283 | explicit |
1284 | const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const) |
1285 | : _M_f(__pf) { } |
1286 | |
1287 | _Ret |
1288 | operator()(const _Tp& __r) const |
1289 | { return (__r.*_M_f)(); } |
1290 | |
1291 | private: |
1292 | _Ret (_Tp::*_M_f)() const; |
1293 | } _GLIBCXX11_DEPRECATED; |
1294 | |
1295 | /// One of the @link ptrmem_adaptors adaptors for member pointers@endlink. |
1296 | template<typename _Ret, typename _Tp, typename _Arg> |
1297 | class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret> |
1298 | { |
1299 | public: |
1300 | explicit |
1301 | mem_fun1_t(_Ret (_Tp::*__pf)(_Arg)) |
1302 | : _M_f(__pf) { } |
1303 | |
1304 | _Ret |
1305 | operator()(_Tp* __p, _Arg __x) const |
1306 | { return (__p->*_M_f)(__x); } |
1307 | |
1308 | private: |
1309 | _Ret (_Tp::*_M_f)(_Arg); |
1310 | } _GLIBCXX11_DEPRECATED; |
1311 | |
1312 | /// One of the @link ptrmem_adaptors adaptors for member pointers@endlink. |
1313 | template<typename _Ret, typename _Tp, typename _Arg> |
1314 | class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret> |
1315 | { |
1316 | public: |
1317 | explicit |
1318 | const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const) |
1319 | : _M_f(__pf) { } |
1320 | |
1321 | _Ret |
1322 | operator()(const _Tp* __p, _Arg __x) const |
1323 | { return (__p->*_M_f)(__x); } |
1324 | |
1325 | private: |
1326 | _Ret (_Tp::*_M_f)(_Arg) const; |
1327 | } _GLIBCXX11_DEPRECATED; |
1328 | |
1329 | /// One of the @link ptrmem_adaptors adaptors for member pointers@endlink. |
1330 | template<typename _Ret, typename _Tp, typename _Arg> |
1331 | class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> |
1332 | { |
1333 | public: |
1334 | explicit |
1335 | mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg)) |
1336 | : _M_f(__pf) { } |
1337 | |
1338 | _Ret |
1339 | operator()(_Tp& __r, _Arg __x) const |
1340 | { return (__r.*_M_f)(__x); } |
1341 | |
1342 | private: |
1343 | _Ret (_Tp::*_M_f)(_Arg); |
1344 | } _GLIBCXX11_DEPRECATED; |
1345 | |
1346 | /// One of the @link ptrmem_adaptors adaptors for member pointers@endlink. |
1347 | template<typename _Ret, typename _Tp, typename _Arg> |
1348 | class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> |
1349 | { |
1350 | public: |
1351 | explicit |
1352 | const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const) |
1353 | : _M_f(__pf) { } |
1354 | |
1355 | _Ret |
1356 | operator()(const _Tp& __r, _Arg __x) const |
1357 | { return (__r.*_M_f)(__x); } |
1358 | |
1359 | private: |
1360 | _Ret (_Tp::*_M_f)(_Arg) const; |
1361 | } _GLIBCXX11_DEPRECATED; |
1362 | |
1363 | // Mem_fun adaptor helper functions. There are only two: |
1364 | // mem_fun and mem_fun_ref. |
1365 | template<typename _Ret, typename _Tp> |
1366 | _GLIBCXX11_DEPRECATED_SUGGEST("std::mem_fn" ) |
1367 | inline mem_fun_t<_Ret, _Tp> |
1368 | mem_fun(_Ret (_Tp::*__f)()) |
1369 | { return mem_fun_t<_Ret, _Tp>(__f); } |
1370 | |
1371 | template<typename _Ret, typename _Tp> |
1372 | _GLIBCXX11_DEPRECATED_SUGGEST("std::mem_fn" ) |
1373 | inline const_mem_fun_t<_Ret, _Tp> |
1374 | mem_fun(_Ret (_Tp::*__f)() const) |
1375 | { return const_mem_fun_t<_Ret, _Tp>(__f); } |
1376 | |
1377 | template<typename _Ret, typename _Tp> |
1378 | _GLIBCXX11_DEPRECATED_SUGGEST("std::mem_fn" ) |
1379 | inline mem_fun_ref_t<_Ret, _Tp> |
1380 | mem_fun_ref(_Ret (_Tp::*__f)()) |
1381 | { return mem_fun_ref_t<_Ret, _Tp>(__f); } |
1382 | |
1383 | template<typename _Ret, typename _Tp> |
1384 | _GLIBCXX11_DEPRECATED_SUGGEST("std::mem_fn" ) |
1385 | inline const_mem_fun_ref_t<_Ret, _Tp> |
1386 | mem_fun_ref(_Ret (_Tp::*__f)() const) |
1387 | { return const_mem_fun_ref_t<_Ret, _Tp>(__f); } |
1388 | |
1389 | template<typename _Ret, typename _Tp, typename _Arg> |
1390 | _GLIBCXX11_DEPRECATED_SUGGEST("std::mem_fn" ) |
1391 | inline mem_fun1_t<_Ret, _Tp, _Arg> |
1392 | mem_fun(_Ret (_Tp::*__f)(_Arg)) |
1393 | { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); } |
1394 | |
1395 | template<typename _Ret, typename _Tp, typename _Arg> |
1396 | _GLIBCXX11_DEPRECATED_SUGGEST("std::mem_fn" ) |
1397 | inline const_mem_fun1_t<_Ret, _Tp, _Arg> |
1398 | mem_fun(_Ret (_Tp::*__f)(_Arg) const) |
1399 | { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); } |
1400 | |
1401 | template<typename _Ret, typename _Tp, typename _Arg> |
1402 | _GLIBCXX11_DEPRECATED_SUGGEST("std::mem_fn" ) |
1403 | inline mem_fun1_ref_t<_Ret, _Tp, _Arg> |
1404 | mem_fun_ref(_Ret (_Tp::*__f)(_Arg)) |
1405 | { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } |
1406 | |
1407 | template<typename _Ret, typename _Tp, typename _Arg> |
1408 | _GLIBCXX11_DEPRECATED_SUGGEST("std::mem_fn" ) |
1409 | inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg> |
1410 | mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const) |
1411 | { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } |
1412 | #pragma GCC diagnostic pop |
1413 | |
1414 | /** @} */ |
1415 | |
1416 | #ifdef __glibcxx_transparent_operators // C++ >= 14 |
1417 | template<typename _Func, typename _SfinaeType, typename = __void_t<>> |
1418 | struct __has_is_transparent |
1419 | { }; |
1420 | |
1421 | template<typename _Func, typename _SfinaeType> |
1422 | struct __has_is_transparent<_Func, _SfinaeType, |
1423 | __void_t<typename _Func::is_transparent>> |
1424 | { typedef void type; }; |
1425 | |
1426 | template<typename _Func, typename _SfinaeType> |
1427 | using __has_is_transparent_t |
1428 | = typename __has_is_transparent<_Func, _SfinaeType>::type; |
1429 | #endif |
1430 | |
1431 | _GLIBCXX_END_NAMESPACE_VERSION |
1432 | } // namespace |
1433 | |
1434 | #if (__cplusplus < 201103L) || _GLIBCXX_USE_DEPRECATED |
1435 | # include <backward/binders.h> |
1436 | #endif |
1437 | |
1438 | #endif /* _STL_FUNCTION_H */ |
1439 | |