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