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