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