1 // Functor implementations -*- C++ -*-
3 // Copyright (C) 2001-2019 Free Software Foundation, Inc.
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)
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.
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.
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/>.
28 * Hewlett-Packard Company
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.
39 * Copyright (c) 1996-1998
40 * Silicon Graphics Computer Systems, Inc.
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.
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}
56 #ifndef _STL_FUNCTION_H
57 #define _STL_FUNCTION_H 1
59 #if __cplusplus > 201103L
60 #include <bits/move.h>
63 namespace std
_GLIBCXX_VISIBILITY(default)
65 _GLIBCXX_BEGIN_NAMESPACE_VERSION
67 // 20.3.1 base classes
68 /** @defgroup functors Function Objects
71 * Function objects, or @e functors, are objects with an @c 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 @a functors, then, generally we include function pointers in
77 * the description as well.
79 * Often, functors are only created as temporaries passed to algorithm
80 * calls, rather than being created as named variables.
82 * Two examples taken from the standard itself follow. To perform a
83 * by-element addition of two vectors @c a and @c b containing @c double,
84 * and put the result in @c a, use
86 * transform (a.begin(), a.end(), b.begin(), a.begin(), plus<double>());
88 * To negate every element in @c a, use
90 * transform(a.begin(), a.end(), a.begin(), negate<double>());
92 * The addition and negation functions will be inlined directly.
94 * The standard functors are derived from structs named @c unary_function
95 * and @c binary_function. These two classes contain nothing but typedefs,
96 * to aid in generic (template) programming. If you write your own
97 * functors, you might consider doing the same.
102 * This is one of the @link functors functor base classes@endlink.
104 template<typename _Arg
, typename _Result
>
105 struct unary_function
107 /// @c argument_type is the type of the argument
108 typedef _Arg argument_type
;
110 /// @c result_type is the return type
111 typedef _Result result_type
;
115 * This is one of the @link functors functor base classes@endlink.
117 template<typename _Arg1
, typename _Arg2
, typename _Result
>
118 struct binary_function
120 /// @c first_argument_type is the type of the first argument
121 typedef _Arg1 first_argument_type
;
123 /// @c second_argument_type is the type of the second argument
124 typedef _Arg2 second_argument_type
;
126 /// @c result_type is the return type
127 typedef _Result result_type
;
132 /** @defgroup arithmetic_functors Arithmetic Classes
135 * Because basic math often needs to be done during an algorithm,
136 * the library provides functors for those operations. See the
137 * documentation for @link functors the base classes@endlink
138 * for examples of their use.
143 #if __cplusplus > 201103L
144 struct __is_transparent
; // undefined
146 template<typename _Tp
= void>
149 template<typename _Tp
= void>
152 template<typename _Tp
= void>
155 template<typename _Tp
= void>
158 template<typename _Tp
= void>
161 template<typename _Tp
= void>
165 /// One of the @link arithmetic_functors math functors@endlink.
166 template<typename _Tp
>
167 struct plus
: public binary_function
<_Tp
, _Tp
, _Tp
>
171 operator()(const _Tp
& __x
, const _Tp
& __y
) const
172 { return __x
+ __y
; }
175 /// One of the @link arithmetic_functors math functors@endlink.
176 template<typename _Tp
>
177 struct minus
: public binary_function
<_Tp
, _Tp
, _Tp
>
181 operator()(const _Tp
& __x
, const _Tp
& __y
) const
182 { return __x
- __y
; }
185 /// One of the @link arithmetic_functors math functors@endlink.
186 template<typename _Tp
>
187 struct multiplies
: public binary_function
<_Tp
, _Tp
, _Tp
>
191 operator()(const _Tp
& __x
, const _Tp
& __y
) const
192 { return __x
* __y
; }
195 /// One of the @link arithmetic_functors math functors@endlink.
196 template<typename _Tp
>
197 struct divides
: public binary_function
<_Tp
, _Tp
, _Tp
>
201 operator()(const _Tp
& __x
, const _Tp
& __y
) const
202 { return __x
/ __y
; }
205 /// One of the @link arithmetic_functors math functors@endlink.
206 template<typename _Tp
>
207 struct modulus
: public binary_function
<_Tp
, _Tp
, _Tp
>
211 operator()(const _Tp
& __x
, const _Tp
& __y
) const
212 { return __x
% __y
; }
215 /// One of the @link arithmetic_functors math functors@endlink.
216 template<typename _Tp
>
217 struct negate
: public unary_function
<_Tp
, _Tp
>
221 operator()(const _Tp
& __x
) const
225 #if __cplusplus > 201103L
227 #define __cpp_lib_transparent_operators 201510
232 template <typename _Tp
, typename _Up
>
235 operator()(_Tp
&& __t
, _Up
&& __u
) const
236 noexcept(noexcept(std::forward
<_Tp
>(__t
) + std::forward
<_Up
>(__u
)))
237 -> decltype(std::forward
<_Tp
>(__t
) + std::forward
<_Up
>(__u
))
238 { return std::forward
<_Tp
>(__t
) + std::forward
<_Up
>(__u
); }
240 typedef __is_transparent is_transparent
;
243 /// One of the @link arithmetic_functors math functors@endlink.
247 template <typename _Tp
, typename _Up
>
250 operator()(_Tp
&& __t
, _Up
&& __u
) const
251 noexcept(noexcept(std::forward
<_Tp
>(__t
) - std::forward
<_Up
>(__u
)))
252 -> decltype(std::forward
<_Tp
>(__t
) - std::forward
<_Up
>(__u
))
253 { return std::forward
<_Tp
>(__t
) - std::forward
<_Up
>(__u
); }
255 typedef __is_transparent is_transparent
;
258 /// One of the @link arithmetic_functors math functors@endlink.
260 struct multiplies
<void>
262 template <typename _Tp
, typename _Up
>
265 operator()(_Tp
&& __t
, _Up
&& __u
) const
266 noexcept(noexcept(std::forward
<_Tp
>(__t
) * std::forward
<_Up
>(__u
)))
267 -> decltype(std::forward
<_Tp
>(__t
) * std::forward
<_Up
>(__u
))
268 { return std::forward
<_Tp
>(__t
) * std::forward
<_Up
>(__u
); }
270 typedef __is_transparent is_transparent
;
273 /// One of the @link arithmetic_functors math functors@endlink.
277 template <typename _Tp
, typename _Up
>
280 operator()(_Tp
&& __t
, _Up
&& __u
) const
281 noexcept(noexcept(std::forward
<_Tp
>(__t
) / std::forward
<_Up
>(__u
)))
282 -> decltype(std::forward
<_Tp
>(__t
) / std::forward
<_Up
>(__u
))
283 { return std::forward
<_Tp
>(__t
) / std::forward
<_Up
>(__u
); }
285 typedef __is_transparent is_transparent
;
288 /// One of the @link arithmetic_functors math functors@endlink.
292 template <typename _Tp
, typename _Up
>
295 operator()(_Tp
&& __t
, _Up
&& __u
) const
296 noexcept(noexcept(std::forward
<_Tp
>(__t
) % std::forward
<_Up
>(__u
)))
297 -> decltype(std::forward
<_Tp
>(__t
) % std::forward
<_Up
>(__u
))
298 { return std::forward
<_Tp
>(__t
) % std::forward
<_Up
>(__u
); }
300 typedef __is_transparent is_transparent
;
303 /// One of the @link arithmetic_functors math functors@endlink.
307 template <typename _Tp
>
310 operator()(_Tp
&& __t
) const
311 noexcept(noexcept(-std::forward
<_Tp
>(__t
)))
312 -> decltype(-std::forward
<_Tp
>(__t
))
313 { return -std::forward
<_Tp
>(__t
); }
315 typedef __is_transparent is_transparent
;
320 // 20.3.3 comparisons
321 /** @defgroup comparison_functors Comparison Classes
324 * The library provides six wrapper functors for all the basic comparisons
329 #if __cplusplus > 201103L
330 template<typename _Tp
= void>
333 template<typename _Tp
= void>
336 template<typename _Tp
= void>
339 template<typename _Tp
= void>
342 template<typename _Tp
= void>
343 struct greater_equal
;
345 template<typename _Tp
= void>
349 /// One of the @link comparison_functors comparison functors@endlink.
350 template<typename _Tp
>
351 struct equal_to
: public binary_function
<_Tp
, _Tp
, bool>
355 operator()(const _Tp
& __x
, const _Tp
& __y
) const
356 { return __x
== __y
; }
359 /// One of the @link comparison_functors comparison functors@endlink.
360 template<typename _Tp
>
361 struct not_equal_to
: public binary_function
<_Tp
, _Tp
, bool>
365 operator()(const _Tp
& __x
, const _Tp
& __y
) const
366 { return __x
!= __y
; }
369 /// One of the @link comparison_functors comparison functors@endlink.
370 template<typename _Tp
>
371 struct greater
: public binary_function
<_Tp
, _Tp
, bool>
375 operator()(const _Tp
& __x
, const _Tp
& __y
) const
376 { return __x
> __y
; }
379 /// One of the @link comparison_functors comparison functors@endlink.
380 template<typename _Tp
>
381 struct less
: public binary_function
<_Tp
, _Tp
, bool>
385 operator()(const _Tp
& __x
, const _Tp
& __y
) const
386 { return __x
< __y
; }
389 /// One of the @link comparison_functors comparison functors@endlink.
390 template<typename _Tp
>
391 struct greater_equal
: public binary_function
<_Tp
, _Tp
, bool>
395 operator()(const _Tp
& __x
, const _Tp
& __y
) const
396 { return __x
>= __y
; }
399 /// One of the @link comparison_functors comparison functors@endlink.
400 template<typename _Tp
>
401 struct less_equal
: public binary_function
<_Tp
, _Tp
, bool>
405 operator()(const _Tp
& __x
, const _Tp
& __y
) const
406 { return __x
<= __y
; }
409 // Partial specialization of std::greater for pointers.
410 template<typename _Tp
>
411 struct greater
<_Tp
*> : public binary_function
<_Tp
*, _Tp
*, bool>
413 _GLIBCXX14_CONSTEXPR
bool
414 operator()(_Tp
* __x
, _Tp
* __y
) const _GLIBCXX_NOTHROW
416 #if __cplusplus >= 201402L
417 #ifdef _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED
418 if (__builtin_is_constant_evaluated())
420 if (__builtin_constant_p(__x
> __y
))
424 return (__UINTPTR_TYPE__
)__x
> (__UINTPTR_TYPE__
)__y
;
428 // Partial specialization of std::less for pointers.
429 template<typename _Tp
>
430 struct less
<_Tp
*> : public binary_function
<_Tp
*, _Tp
*, bool>
432 _GLIBCXX14_CONSTEXPR
bool
433 operator()(_Tp
* __x
, _Tp
* __y
) const _GLIBCXX_NOTHROW
435 #if __cplusplus >= 201402L
436 #ifdef _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED
437 if (__builtin_is_constant_evaluated())
439 if (__builtin_constant_p(__x
< __y
))
443 return (__UINTPTR_TYPE__
)__x
< (__UINTPTR_TYPE__
)__y
;
447 // Partial specialization of std::greater_equal for pointers.
448 template<typename _Tp
>
449 struct greater_equal
<_Tp
*> : public binary_function
<_Tp
*, _Tp
*, bool>
451 _GLIBCXX14_CONSTEXPR
bool
452 operator()(_Tp
* __x
, _Tp
* __y
) const _GLIBCXX_NOTHROW
454 #if __cplusplus >= 201402L
455 #ifdef _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED
456 if (__builtin_is_constant_evaluated())
458 if (__builtin_constant_p(__x
>= __y
))
462 return (__UINTPTR_TYPE__
)__x
>= (__UINTPTR_TYPE__
)__y
;
466 // Partial specialization of std::less_equal for pointers.
467 template<typename _Tp
>
468 struct less_equal
<_Tp
*> : public binary_function
<_Tp
*, _Tp
*, bool>
470 _GLIBCXX14_CONSTEXPR
bool
471 operator()(_Tp
* __x
, _Tp
* __y
) const _GLIBCXX_NOTHROW
473 #if __cplusplus >= 201402L
474 #ifdef _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED
475 if (__builtin_is_constant_evaluated())
477 if (__builtin_constant_p(__x
<= __y
))
481 return (__UINTPTR_TYPE__
)__x
<= (__UINTPTR_TYPE__
)__y
;
485 #if __cplusplus >= 201402L
486 /// One of the @link comparison_functors comparison functors@endlink.
488 struct equal_to
<void>
490 template <typename _Tp
, typename _Up
>
492 operator()(_Tp
&& __t
, _Up
&& __u
) const
493 noexcept(noexcept(std::forward
<_Tp
>(__t
) == std::forward
<_Up
>(__u
)))
494 -> decltype(std::forward
<_Tp
>(__t
) == std::forward
<_Up
>(__u
))
495 { return std::forward
<_Tp
>(__t
) == std::forward
<_Up
>(__u
); }
497 typedef __is_transparent is_transparent
;
500 /// One of the @link comparison_functors comparison functors@endlink.
502 struct not_equal_to
<void>
504 template <typename _Tp
, typename _Up
>
506 operator()(_Tp
&& __t
, _Up
&& __u
) const
507 noexcept(noexcept(std::forward
<_Tp
>(__t
) != std::forward
<_Up
>(__u
)))
508 -> decltype(std::forward
<_Tp
>(__t
) != std::forward
<_Up
>(__u
))
509 { return std::forward
<_Tp
>(__t
) != std::forward
<_Up
>(__u
); }
511 typedef __is_transparent is_transparent
;
514 /// One of the @link comparison_functors comparison functors@endlink.
518 template <typename _Tp
, typename _Up
>
520 operator()(_Tp
&& __t
, _Up
&& __u
) const
521 noexcept(noexcept(std::forward
<_Tp
>(__t
) > std::forward
<_Up
>(__u
)))
522 -> decltype(std::forward
<_Tp
>(__t
) > std::forward
<_Up
>(__u
))
524 return _S_cmp(std::forward
<_Tp
>(__t
), std::forward
<_Up
>(__u
),
525 __ptr_cmp
<_Tp
, _Up
>{});
528 template<typename _Tp
, typename _Up
>
530 operator()(_Tp
* __t
, _Up
* __u
) const noexcept
531 { return greater
<common_type_t
<_Tp
*, _Up
*>>{}(__t
, __u
); }
533 typedef __is_transparent is_transparent
;
536 template <typename _Tp
, typename _Up
>
537 static constexpr decltype(auto)
538 _S_cmp(_Tp
&& __t
, _Up
&& __u
, false_type
)
539 { return std::forward
<_Tp
>(__t
) > std::forward
<_Up
>(__u
); }
541 template <typename _Tp
, typename _Up
>
542 static constexpr bool
543 _S_cmp(_Tp
&& __t
, _Up
&& __u
, true_type
) noexcept
545 return greater
<const volatile void*>{}(
546 static_cast<const volatile void*>(std::forward
<_Tp
>(__t
)),
547 static_cast<const volatile void*>(std::forward
<_Up
>(__u
)));
550 // True if there is no viable operator> member function.
551 template<typename _Tp
, typename _Up
, typename
= void>
552 struct __not_overloaded2
: true_type
{ };
554 // False if we can call T.operator>(U)
555 template<typename _Tp
, typename _Up
>
556 struct __not_overloaded2
<_Tp
, _Up
, __void_t
<
557 decltype(std::declval
<_Tp
>().operator>(std::declval
<_Up
>()))>>
560 // True if there is no overloaded operator> for these operands.
561 template<typename _Tp
, typename _Up
, typename
= void>
562 struct __not_overloaded
: __not_overloaded2
<_Tp
, _Up
> { };
564 // False if we can call operator>(T,U)
565 template<typename _Tp
, typename _Up
>
566 struct __not_overloaded
<_Tp
, _Up
, __void_t
<
567 decltype(operator>(std::declval
<_Tp
>(), std::declval
<_Up
>()))>>
570 template<typename _Tp
, typename _Up
>
571 using __ptr_cmp
= __and_
<__not_overloaded
<_Tp
, _Up
>,
572 is_convertible
<_Tp
, const volatile void*>,
573 is_convertible
<_Up
, const volatile void*>>;
576 /// One of the @link comparison_functors comparison functors@endlink.
580 template <typename _Tp
, typename _Up
>
582 operator()(_Tp
&& __t
, _Up
&& __u
) const
583 noexcept(noexcept(std::forward
<_Tp
>(__t
) < std::forward
<_Up
>(__u
)))
584 -> decltype(std::forward
<_Tp
>(__t
) < std::forward
<_Up
>(__u
))
586 return _S_cmp(std::forward
<_Tp
>(__t
), std::forward
<_Up
>(__u
),
587 __ptr_cmp
<_Tp
, _Up
>{});
590 template<typename _Tp
, typename _Up
>
592 operator()(_Tp
* __t
, _Up
* __u
) const noexcept
593 { return less
<common_type_t
<_Tp
*, _Up
*>>{}(__t
, __u
); }
595 typedef __is_transparent is_transparent
;
598 template <typename _Tp
, typename _Up
>
599 static constexpr decltype(auto)
600 _S_cmp(_Tp
&& __t
, _Up
&& __u
, false_type
)
601 { return std::forward
<_Tp
>(__t
) < std::forward
<_Up
>(__u
); }
603 template <typename _Tp
, typename _Up
>
604 static constexpr bool
605 _S_cmp(_Tp
&& __t
, _Up
&& __u
, true_type
) noexcept
607 return less
<const volatile void*>{}(
608 static_cast<const volatile void*>(std::forward
<_Tp
>(__t
)),
609 static_cast<const volatile void*>(std::forward
<_Up
>(__u
)));
612 // True if there is no viable operator< member function.
613 template<typename _Tp
, typename _Up
, typename
= void>
614 struct __not_overloaded2
: true_type
{ };
616 // False if we can call T.operator<(U)
617 template<typename _Tp
, typename _Up
>
618 struct __not_overloaded2
<_Tp
, _Up
, __void_t
<
619 decltype(std::declval
<_Tp
>().operator<(std::declval
<_Up
>()))>>
622 // True if there is no overloaded operator< for these operands.
623 template<typename _Tp
, typename _Up
, typename
= void>
624 struct __not_overloaded
: __not_overloaded2
<_Tp
, _Up
> { };
626 // False if we can call operator<(T,U)
627 template<typename _Tp
, typename _Up
>
628 struct __not_overloaded
<_Tp
, _Up
, __void_t
<
629 decltype(operator<(std::declval
<_Tp
>(), std::declval
<_Up
>()))>>
632 template<typename _Tp
, typename _Up
>
633 using __ptr_cmp
= __and_
<__not_overloaded
<_Tp
, _Up
>,
634 is_convertible
<_Tp
, const volatile void*>,
635 is_convertible
<_Up
, const volatile void*>>;
638 /// One of the @link comparison_functors comparison functors@endlink.
640 struct greater_equal
<void>
642 template <typename _Tp
, typename _Up
>
644 operator()(_Tp
&& __t
, _Up
&& __u
) const
645 noexcept(noexcept(std::forward
<_Tp
>(__t
) >= std::forward
<_Up
>(__u
)))
646 -> decltype(std::forward
<_Tp
>(__t
) >= std::forward
<_Up
>(__u
))
648 return _S_cmp(std::forward
<_Tp
>(__t
), std::forward
<_Up
>(__u
),
649 __ptr_cmp
<_Tp
, _Up
>{});
652 template<typename _Tp
, typename _Up
>
654 operator()(_Tp
* __t
, _Up
* __u
) const noexcept
655 { return greater_equal
<common_type_t
<_Tp
*, _Up
*>>{}(__t
, __u
); }
657 typedef __is_transparent is_transparent
;
660 template <typename _Tp
, typename _Up
>
661 static constexpr decltype(auto)
662 _S_cmp(_Tp
&& __t
, _Up
&& __u
, false_type
)
663 { return std::forward
<_Tp
>(__t
) >= std::forward
<_Up
>(__u
); }
665 template <typename _Tp
, typename _Up
>
666 static constexpr bool
667 _S_cmp(_Tp
&& __t
, _Up
&& __u
, true_type
) noexcept
669 return greater_equal
<const volatile void*>{}(
670 static_cast<const volatile void*>(std::forward
<_Tp
>(__t
)),
671 static_cast<const volatile void*>(std::forward
<_Up
>(__u
)));
674 // True if there is no viable operator>= member function.
675 template<typename _Tp
, typename _Up
, typename
= void>
676 struct __not_overloaded2
: true_type
{ };
678 // False if we can call T.operator>=(U)
679 template<typename _Tp
, typename _Up
>
680 struct __not_overloaded2
<_Tp
, _Up
, __void_t
<
681 decltype(std::declval
<_Tp
>().operator>=(std::declval
<_Up
>()))>>
684 // True if there is no overloaded operator>= for these operands.
685 template<typename _Tp
, typename _Up
, typename
= void>
686 struct __not_overloaded
: __not_overloaded2
<_Tp
, _Up
> { };
688 // False if we can call operator>=(T,U)
689 template<typename _Tp
, typename _Up
>
690 struct __not_overloaded
<_Tp
, _Up
, __void_t
<
691 decltype(operator>=(std::declval
<_Tp
>(), std::declval
<_Up
>()))>>
694 template<typename _Tp
, typename _Up
>
695 using __ptr_cmp
= __and_
<__not_overloaded
<_Tp
, _Up
>,
696 is_convertible
<_Tp
, const volatile void*>,
697 is_convertible
<_Up
, const volatile void*>>;
700 /// One of the @link comparison_functors comparison functors@endlink.
702 struct less_equal
<void>
704 template <typename _Tp
, typename _Up
>
706 operator()(_Tp
&& __t
, _Up
&& __u
) const
707 noexcept(noexcept(std::forward
<_Tp
>(__t
) <= std::forward
<_Up
>(__u
)))
708 -> decltype(std::forward
<_Tp
>(__t
) <= std::forward
<_Up
>(__u
))
710 return _S_cmp(std::forward
<_Tp
>(__t
), std::forward
<_Up
>(__u
),
711 __ptr_cmp
<_Tp
, _Up
>{});
714 template<typename _Tp
, typename _Up
>
716 operator()(_Tp
* __t
, _Up
* __u
) const noexcept
717 { return less_equal
<common_type_t
<_Tp
*, _Up
*>>{}(__t
, __u
); }
719 typedef __is_transparent is_transparent
;
722 template <typename _Tp
, typename _Up
>
723 static constexpr decltype(auto)
724 _S_cmp(_Tp
&& __t
, _Up
&& __u
, false_type
)
725 { return std::forward
<_Tp
>(__t
) <= std::forward
<_Up
>(__u
); }
727 template <typename _Tp
, typename _Up
>
728 static constexpr bool
729 _S_cmp(_Tp
&& __t
, _Up
&& __u
, true_type
) noexcept
731 return less_equal
<const volatile void*>{}(
732 static_cast<const volatile void*>(std::forward
<_Tp
>(__t
)),
733 static_cast<const volatile void*>(std::forward
<_Up
>(__u
)));
736 // True if there is no viable operator<= member function.
737 template<typename _Tp
, typename _Up
, typename
= void>
738 struct __not_overloaded2
: true_type
{ };
740 // False if we can call T.operator<=(U)
741 template<typename _Tp
, typename _Up
>
742 struct __not_overloaded2
<_Tp
, _Up
, __void_t
<
743 decltype(std::declval
<_Tp
>().operator<=(std::declval
<_Up
>()))>>
746 // True if there is no overloaded operator<= for these operands.
747 template<typename _Tp
, typename _Up
, typename
= void>
748 struct __not_overloaded
: __not_overloaded2
<_Tp
, _Up
> { };
750 // False if we can call operator<=(T,U)
751 template<typename _Tp
, typename _Up
>
752 struct __not_overloaded
<_Tp
, _Up
, __void_t
<
753 decltype(operator<=(std::declval
<_Tp
>(), std::declval
<_Up
>()))>>
756 template<typename _Tp
, typename _Up
>
757 using __ptr_cmp
= __and_
<__not_overloaded
<_Tp
, _Up
>,
758 is_convertible
<_Tp
, const volatile void*>,
759 is_convertible
<_Up
, const volatile void*>>;
764 // 20.3.4 logical operations
765 /** @defgroup logical_functors Boolean Operations Classes
768 * Here are wrapper functors for Boolean operations: @c &&, @c ||,
773 #if __cplusplus > 201103L
774 template<typename _Tp
= void>
777 template<typename _Tp
= void>
780 template<typename _Tp
= void>
784 /// One of the @link logical_functors Boolean operations functors@endlink.
785 template<typename _Tp
>
786 struct logical_and
: public binary_function
<_Tp
, _Tp
, bool>
790 operator()(const _Tp
& __x
, const _Tp
& __y
) const
791 { return __x
&& __y
; }
794 /// One of the @link logical_functors Boolean operations functors@endlink.
795 template<typename _Tp
>
796 struct logical_or
: public binary_function
<_Tp
, _Tp
, bool>
800 operator()(const _Tp
& __x
, const _Tp
& __y
) const
801 { return __x
|| __y
; }
804 /// One of the @link logical_functors Boolean operations functors@endlink.
805 template<typename _Tp
>
806 struct logical_not
: public unary_function
<_Tp
, bool>
810 operator()(const _Tp
& __x
) const
814 #if __cplusplus > 201103L
815 /// One of the @link logical_functors Boolean operations functors@endlink.
817 struct logical_and
<void>
819 template <typename _Tp
, typename _Up
>
822 operator()(_Tp
&& __t
, _Up
&& __u
) const
823 noexcept(noexcept(std::forward
<_Tp
>(__t
) && std::forward
<_Up
>(__u
)))
824 -> decltype(std::forward
<_Tp
>(__t
) && std::forward
<_Up
>(__u
))
825 { return std::forward
<_Tp
>(__t
) && std::forward
<_Up
>(__u
); }
827 typedef __is_transparent is_transparent
;
830 /// One of the @link logical_functors Boolean operations functors@endlink.
832 struct logical_or
<void>
834 template <typename _Tp
, typename _Up
>
837 operator()(_Tp
&& __t
, _Up
&& __u
) const
838 noexcept(noexcept(std::forward
<_Tp
>(__t
) || std::forward
<_Up
>(__u
)))
839 -> decltype(std::forward
<_Tp
>(__t
) || std::forward
<_Up
>(__u
))
840 { return std::forward
<_Tp
>(__t
) || std::forward
<_Up
>(__u
); }
842 typedef __is_transparent is_transparent
;
845 /// One of the @link logical_functors Boolean operations functors@endlink.
847 struct logical_not
<void>
849 template <typename _Tp
>
852 operator()(_Tp
&& __t
) const
853 noexcept(noexcept(!std::forward
<_Tp
>(__t
)))
854 -> decltype(!std::forward
<_Tp
>(__t
))
855 { return !std::forward
<_Tp
>(__t
); }
857 typedef __is_transparent is_transparent
;
862 #if __cplusplus > 201103L
863 template<typename _Tp
= void>
866 template<typename _Tp
= void>
869 template<typename _Tp
= void>
872 template<typename _Tp
= void>
876 // _GLIBCXX_RESOLVE_LIB_DEFECTS
877 // DR 660. Missing Bitwise Operations.
878 template<typename _Tp
>
879 struct bit_and
: public binary_function
<_Tp
, _Tp
, _Tp
>
883 operator()(const _Tp
& __x
, const _Tp
& __y
) const
884 { return __x
& __y
; }
887 template<typename _Tp
>
888 struct bit_or
: public binary_function
<_Tp
, _Tp
, _Tp
>
892 operator()(const _Tp
& __x
, const _Tp
& __y
) const
893 { return __x
| __y
; }
896 template<typename _Tp
>
897 struct bit_xor
: public binary_function
<_Tp
, _Tp
, _Tp
>
901 operator()(const _Tp
& __x
, const _Tp
& __y
) const
902 { return __x
^ __y
; }
905 template<typename _Tp
>
906 struct bit_not
: public unary_function
<_Tp
, _Tp
>
910 operator()(const _Tp
& __x
) const
914 #if __cplusplus > 201103L
918 template <typename _Tp
, typename _Up
>
921 operator()(_Tp
&& __t
, _Up
&& __u
) const
922 noexcept(noexcept(std::forward
<_Tp
>(__t
) & std::forward
<_Up
>(__u
)))
923 -> decltype(std::forward
<_Tp
>(__t
) & std::forward
<_Up
>(__u
))
924 { return std::forward
<_Tp
>(__t
) & std::forward
<_Up
>(__u
); }
926 typedef __is_transparent is_transparent
;
932 template <typename _Tp
, typename _Up
>
935 operator()(_Tp
&& __t
, _Up
&& __u
) const
936 noexcept(noexcept(std::forward
<_Tp
>(__t
) | std::forward
<_Up
>(__u
)))
937 -> decltype(std::forward
<_Tp
>(__t
) | std::forward
<_Up
>(__u
))
938 { return std::forward
<_Tp
>(__t
) | std::forward
<_Up
>(__u
); }
940 typedef __is_transparent is_transparent
;
946 template <typename _Tp
, typename _Up
>
949 operator()(_Tp
&& __t
, _Up
&& __u
) const
950 noexcept(noexcept(std::forward
<_Tp
>(__t
) ^ std::forward
<_Up
>(__u
)))
951 -> decltype(std::forward
<_Tp
>(__t
) ^ std::forward
<_Up
>(__u
))
952 { return std::forward
<_Tp
>(__t
) ^ std::forward
<_Up
>(__u
); }
954 typedef __is_transparent is_transparent
;
960 template <typename _Tp
>
963 operator()(_Tp
&& __t
) const
964 noexcept(noexcept(~std::forward
<_Tp
>(__t
)))
965 -> decltype(~std::forward
<_Tp
>(__t
))
966 { return ~std::forward
<_Tp
>(__t
); }
968 typedef __is_transparent is_transparent
;
973 /** @defgroup negators Negators
976 * The functions @c not1 and @c not2 each take a predicate functor
977 * and return an instance of @c unary_negate or
978 * @c binary_negate, respectively. These classes are functors whose
979 * @c operator() performs the stored predicate function and then returns
980 * the negation of the result.
982 * For example, given a vector of integers and a trivial predicate,
984 * struct IntGreaterThanThree
985 * : public std::unary_function<int, bool>
987 * bool operator() (int x) { return x > 3; }
990 * std::find_if (v.begin(), v.end(), not1(IntGreaterThanThree()));
992 * The call to @c find_if will locate the first index (i) of @c v for which
993 * <code>!(v[i] > 3)</code> is true.
995 * The not1/unary_negate combination works on predicates taking a single
996 * argument. The not2/binary_negate combination works on predicates which
997 * take two arguments.
1001 /// One of the @link negators negation functors@endlink.
1002 template<typename _Predicate
>
1004 : public unary_function
<typename
_Predicate::argument_type
, bool>
1010 _GLIBCXX14_CONSTEXPR
1012 unary_negate(const _Predicate
& __x
) : _M_pred(__x
) { }
1014 _GLIBCXX14_CONSTEXPR
1016 operator()(const typename
_Predicate::argument_type
& __x
) const
1017 { return !_M_pred(__x
); }
1020 /// One of the @link negators negation functors@endlink.
1021 template<typename _Predicate
>
1022 _GLIBCXX14_CONSTEXPR
1023 inline unary_negate
<_Predicate
>
1024 not1(const _Predicate
& __pred
)
1025 { return unary_negate
<_Predicate
>(__pred
); }
1027 /// One of the @link negators negation functors@endlink.
1028 template<typename _Predicate
>
1030 : public binary_function
<typename
_Predicate::first_argument_type
,
1031 typename
_Predicate::second_argument_type
, bool>
1037 _GLIBCXX14_CONSTEXPR
1039 binary_negate(const _Predicate
& __x
) : _M_pred(__x
) { }
1041 _GLIBCXX14_CONSTEXPR
1043 operator()(const typename
_Predicate::first_argument_type
& __x
,
1044 const typename
_Predicate::second_argument_type
& __y
) const
1045 { return !_M_pred(__x
, __y
); }
1048 /// One of the @link negators negation functors@endlink.
1049 template<typename _Predicate
>
1050 _GLIBCXX14_CONSTEXPR
1051 inline binary_negate
<_Predicate
>
1052 not2(const _Predicate
& __pred
)
1053 { return binary_negate
<_Predicate
>(__pred
); }
1056 // 20.3.7 adaptors pointers functions
1057 /** @defgroup pointer_adaptors Adaptors for pointers to functions
1060 * The advantage of function objects over pointers to functions is that
1061 * the objects in the standard library declare nested typedefs describing
1062 * their argument and result types with uniform names (e.g., @c result_type
1063 * from the base classes @c unary_function and @c binary_function).
1064 * Sometimes those typedefs are required, not just optional.
1066 * Adaptors are provided to turn pointers to unary (single-argument) and
1067 * binary (double-argument) functions into function objects. The
1068 * long-winded functor @c pointer_to_unary_function is constructed with a
1069 * function pointer @c f, and its @c operator() called with argument @c x
1070 * returns @c f(x). The functor @c pointer_to_binary_function does the same
1071 * thing, but with a double-argument @c f and @c operator().
1073 * The function @c ptr_fun takes a pointer-to-function @c f and constructs
1074 * an instance of the appropriate functor.
1078 /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
1079 template<typename _Arg
, typename _Result
>
1080 class pointer_to_unary_function
: public unary_function
<_Arg
, _Result
>
1083 _Result (*_M_ptr
)(_Arg
);
1086 pointer_to_unary_function() { }
1089 pointer_to_unary_function(_Result (*__x
)(_Arg
))
1093 operator()(_Arg __x
) const
1094 { return _M_ptr(__x
); }
1097 /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
1098 template<typename _Arg
, typename _Result
>
1099 inline pointer_to_unary_function
<_Arg
, _Result
>
1100 ptr_fun(_Result (*__x
)(_Arg
))
1101 { return pointer_to_unary_function
<_Arg
, _Result
>(__x
); }
1103 /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
1104 template<typename _Arg1
, typename _Arg2
, typename _Result
>
1105 class pointer_to_binary_function
1106 : public binary_function
<_Arg1
, _Arg2
, _Result
>
1109 _Result (*_M_ptr
)(_Arg1
, _Arg2
);
1112 pointer_to_binary_function() { }
1115 pointer_to_binary_function(_Result (*__x
)(_Arg1
, _Arg2
))
1119 operator()(_Arg1 __x
, _Arg2 __y
) const
1120 { return _M_ptr(__x
, __y
); }
1123 /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
1124 template<typename _Arg1
, typename _Arg2
, typename _Result
>
1125 inline pointer_to_binary_function
<_Arg1
, _Arg2
, _Result
>
1126 ptr_fun(_Result (*__x
)(_Arg1
, _Arg2
))
1127 { return pointer_to_binary_function
<_Arg1
, _Arg2
, _Result
>(__x
); }
1130 template<typename _Tp
>
1132 : public unary_function
<_Tp
, _Tp
>
1135 operator()(_Tp
& __x
) const
1139 operator()(const _Tp
& __x
) const
1143 // Partial specialization, avoids confusing errors in e.g. std::set<const T>.
1144 template<typename _Tp
> struct _Identity
<const _Tp
> : _Identity
<_Tp
> { };
1146 template<typename _Pair
>
1148 : public unary_function
<_Pair
, typename
_Pair::first_type
>
1150 typename
_Pair::first_type
&
1151 operator()(_Pair
& __x
) const
1152 { return __x
.first
; }
1154 const typename
_Pair::first_type
&
1155 operator()(const _Pair
& __x
) const
1156 { return __x
.first
; }
1158 #if __cplusplus >= 201103L
1159 template<typename _Pair2
>
1160 typename
_Pair2::first_type
&
1161 operator()(_Pair2
& __x
) const
1162 { return __x
.first
; }
1164 template<typename _Pair2
>
1165 const typename
_Pair2::first_type
&
1166 operator()(const _Pair2
& __x
) const
1167 { return __x
.first
; }
1171 template<typename _Pair
>
1173 : public unary_function
<_Pair
, typename
_Pair::second_type
>
1175 typename
_Pair::second_type
&
1176 operator()(_Pair
& __x
) const
1177 { return __x
.second
; }
1179 const typename
_Pair::second_type
&
1180 operator()(const _Pair
& __x
) const
1181 { return __x
.second
; }
1184 // 20.3.8 adaptors pointers members
1185 /** @defgroup memory_adaptors Adaptors for pointers to members
1188 * There are a total of 8 = 2^3 function objects in this family.
1189 * (1) Member functions taking no arguments vs member functions taking
1191 * (2) Call through pointer vs call through reference.
1192 * (3) Const vs non-const member function.
1194 * All of this complexity is in the function objects themselves. You can
1195 * ignore it by using the helper function mem_fun and mem_fun_ref,
1196 * which create whichever type of adaptor is appropriate.
1200 /// One of the @link memory_adaptors adaptors for member
1201 /// pointers@endlink.
1202 template<typename _Ret
, typename _Tp
>
1203 class mem_fun_t
: public unary_function
<_Tp
*, _Ret
>
1207 mem_fun_t(_Ret (_Tp::*__pf
)())
1211 operator()(_Tp
* __p
) const
1212 { return (__p
->*_M_f
)(); }
1215 _Ret (_Tp::*_M_f
)();
1218 /// One of the @link memory_adaptors adaptors for member
1219 /// pointers@endlink.
1220 template<typename _Ret
, typename _Tp
>
1221 class const_mem_fun_t
: public unary_function
<const _Tp
*, _Ret
>
1225 const_mem_fun_t(_Ret (_Tp::*__pf
)() const)
1229 operator()(const _Tp
* __p
) const
1230 { return (__p
->*_M_f
)(); }
1233 _Ret (_Tp::*_M_f
)() const;
1236 /// One of the @link memory_adaptors adaptors for member
1237 /// pointers@endlink.
1238 template<typename _Ret
, typename _Tp
>
1239 class mem_fun_ref_t
: public unary_function
<_Tp
, _Ret
>
1243 mem_fun_ref_t(_Ret (_Tp::*__pf
)())
1247 operator()(_Tp
& __r
) const
1248 { return (__r
.*_M_f
)(); }
1251 _Ret (_Tp::*_M_f
)();
1254 /// One of the @link memory_adaptors adaptors for member
1255 /// pointers@endlink.
1256 template<typename _Ret
, typename _Tp
>
1257 class const_mem_fun_ref_t
: public unary_function
<_Tp
, _Ret
>
1261 const_mem_fun_ref_t(_Ret (_Tp::*__pf
)() const)
1265 operator()(const _Tp
& __r
) const
1266 { return (__r
.*_M_f
)(); }
1269 _Ret (_Tp::*_M_f
)() const;
1272 /// One of the @link memory_adaptors adaptors for member
1273 /// pointers@endlink.
1274 template<typename _Ret
, typename _Tp
, typename _Arg
>
1275 class mem_fun1_t
: public binary_function
<_Tp
*, _Arg
, _Ret
>
1279 mem_fun1_t(_Ret (_Tp::*__pf
)(_Arg
))
1283 operator()(_Tp
* __p
, _Arg __x
) const
1284 { return (__p
->*_M_f
)(__x
); }
1287 _Ret (_Tp::*_M_f
)(_Arg
);
1290 /// One of the @link memory_adaptors adaptors for member
1291 /// pointers@endlink.
1292 template<typename _Ret
, typename _Tp
, typename _Arg
>
1293 class const_mem_fun1_t
: public binary_function
<const _Tp
*, _Arg
, _Ret
>
1297 const_mem_fun1_t(_Ret (_Tp::*__pf
)(_Arg
) const)
1301 operator()(const _Tp
* __p
, _Arg __x
) const
1302 { return (__p
->*_M_f
)(__x
); }
1305 _Ret (_Tp::*_M_f
)(_Arg
) const;
1308 /// One of the @link memory_adaptors adaptors for member
1309 /// pointers@endlink.
1310 template<typename _Ret
, typename _Tp
, typename _Arg
>
1311 class mem_fun1_ref_t
: public binary_function
<_Tp
, _Arg
, _Ret
>
1315 mem_fun1_ref_t(_Ret (_Tp::*__pf
)(_Arg
))
1319 operator()(_Tp
& __r
, _Arg __x
) const
1320 { return (__r
.*_M_f
)(__x
); }
1323 _Ret (_Tp::*_M_f
)(_Arg
);
1326 /// One of the @link memory_adaptors adaptors for member
1327 /// pointers@endlink.
1328 template<typename _Ret
, typename _Tp
, typename _Arg
>
1329 class const_mem_fun1_ref_t
: public binary_function
<_Tp
, _Arg
, _Ret
>
1333 const_mem_fun1_ref_t(_Ret (_Tp::*__pf
)(_Arg
) const)
1337 operator()(const _Tp
& __r
, _Arg __x
) const
1338 { return (__r
.*_M_f
)(__x
); }
1341 _Ret (_Tp::*_M_f
)(_Arg
) const;
1344 // Mem_fun adaptor helper functions. There are only two:
1345 // mem_fun and mem_fun_ref.
1346 template<typename _Ret
, typename _Tp
>
1347 inline mem_fun_t
<_Ret
, _Tp
>
1348 mem_fun(_Ret (_Tp::*__f
)())
1349 { return mem_fun_t
<_Ret
, _Tp
>(__f
); }
1351 template<typename _Ret
, typename _Tp
>
1352 inline const_mem_fun_t
<_Ret
, _Tp
>
1353 mem_fun(_Ret (_Tp::*__f
)() const)
1354 { return const_mem_fun_t
<_Ret
, _Tp
>(__f
); }
1356 template<typename _Ret
, typename _Tp
>
1357 inline mem_fun_ref_t
<_Ret
, _Tp
>
1358 mem_fun_ref(_Ret (_Tp::*__f
)())
1359 { return mem_fun_ref_t
<_Ret
, _Tp
>(__f
); }
1361 template<typename _Ret
, typename _Tp
>
1362 inline const_mem_fun_ref_t
<_Ret
, _Tp
>
1363 mem_fun_ref(_Ret (_Tp::*__f
)() const)
1364 { return const_mem_fun_ref_t
<_Ret
, _Tp
>(__f
); }
1366 template<typename _Ret
, typename _Tp
, typename _Arg
>
1367 inline mem_fun1_t
<_Ret
, _Tp
, _Arg
>
1368 mem_fun(_Ret (_Tp::*__f
)(_Arg
))
1369 { return mem_fun1_t
<_Ret
, _Tp
, _Arg
>(__f
); }
1371 template<typename _Ret
, typename _Tp
, typename _Arg
>
1372 inline const_mem_fun1_t
<_Ret
, _Tp
, _Arg
>
1373 mem_fun(_Ret (_Tp::*__f
)(_Arg
) const)
1374 { return const_mem_fun1_t
<_Ret
, _Tp
, _Arg
>(__f
); }
1376 template<typename _Ret
, typename _Tp
, typename _Arg
>
1377 inline mem_fun1_ref_t
<_Ret
, _Tp
, _Arg
>
1378 mem_fun_ref(_Ret (_Tp::*__f
)(_Arg
))
1379 { return mem_fun1_ref_t
<_Ret
, _Tp
, _Arg
>(__f
); }
1381 template<typename _Ret
, typename _Tp
, typename _Arg
>
1382 inline const_mem_fun1_ref_t
<_Ret
, _Tp
, _Arg
>
1383 mem_fun_ref(_Ret (_Tp::*__f
)(_Arg
) const)
1384 { return const_mem_fun1_ref_t
<_Ret
, _Tp
, _Arg
>(__f
); }
1388 _GLIBCXX_END_NAMESPACE_VERSION
1391 #if (__cplusplus < 201103L) || _GLIBCXX_USE_DEPRECATED
1392 # include <backward/binders.h>
1395 #endif /* _STL_FUNCTION_H */