libstdc++
stl_function.h
Go to the documentation of this file.
1// Functor implementations -*- C++ -*-
2
3// Copyright (C) 2001-2016 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
122
123 /// @c second_argument_type is the type of the second argument
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 201210
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
256 };
257
258 /// One of the @link arithmetic_functors math functors@endlink.
259 template<>
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
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
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
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
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#if __cplusplus > 201103L
410 /// One of the @link comparison_functors comparison functors@endlink.
411 template<>
413 {
414 template <typename _Tp, typename _Up>
415 _GLIBCXX14_CONSTEXPR
416 auto
417 operator()(_Tp&& __t, _Up&& __u) const
418 noexcept(noexcept(std::forward<_Tp>(__t) == std::forward<_Up>(__u)))
419 -> decltype(std::forward<_Tp>(__t) == std::forward<_Up>(__u))
420 { return std::forward<_Tp>(__t) == std::forward<_Up>(__u); }
421
423 };
424
425 /// One of the @link comparison_functors comparison functors@endlink.
426 template<>
428 {
429 template <typename _Tp, typename _Up>
430 _GLIBCXX14_CONSTEXPR
431 auto
432 operator()(_Tp&& __t, _Up&& __u) const
433 noexcept(noexcept(std::forward<_Tp>(__t) != std::forward<_Up>(__u)))
434 -> decltype(std::forward<_Tp>(__t) != std::forward<_Up>(__u))
435 { return std::forward<_Tp>(__t) != std::forward<_Up>(__u); }
436
438 };
439
440 /// One of the @link comparison_functors comparison functors@endlink.
441 template<>
442 struct greater<void>
443 {
444 template <typename _Tp, typename _Up>
445 _GLIBCXX14_CONSTEXPR
446 auto
447 operator()(_Tp&& __t, _Up&& __u) const
448 noexcept(noexcept(std::forward<_Tp>(__t) > std::forward<_Up>(__u)))
449 -> decltype(std::forward<_Tp>(__t) > std::forward<_Up>(__u))
450 { return std::forward<_Tp>(__t) > std::forward<_Up>(__u); }
451
453 };
454
455 /// One of the @link comparison_functors comparison functors@endlink.
456 template<>
457 struct less<void>
458 {
459 template <typename _Tp, typename _Up>
460 _GLIBCXX14_CONSTEXPR
461 auto
462 operator()(_Tp&& __t, _Up&& __u) const
463 noexcept(noexcept(std::forward<_Tp>(__t) < std::forward<_Up>(__u)))
464 -> decltype(std::forward<_Tp>(__t) < std::forward<_Up>(__u))
465 { return std::forward<_Tp>(__t) < std::forward<_Up>(__u); }
466
468 };
469
470 /// One of the @link comparison_functors comparison functors@endlink.
471 template<>
473 {
474 template <typename _Tp, typename _Up>
475 _GLIBCXX14_CONSTEXPR
476 auto
477 operator()(_Tp&& __t, _Up&& __u) const
478 noexcept(noexcept(std::forward<_Tp>(__t) >= std::forward<_Up>(__u)))
479 -> decltype(std::forward<_Tp>(__t) >= std::forward<_Up>(__u))
480 { return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); }
481
483 };
484
485 /// One of the @link comparison_functors comparison functors@endlink.
486 template<>
488 {
489 template <typename _Tp, typename _Up>
490 _GLIBCXX14_CONSTEXPR
491 auto
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); }
496
498 };
499#endif
500 /** @} */
501
502 // 20.3.4 logical operations
503 /** @defgroup logical_functors Boolean Operations Classes
504 * @ingroup functors
505 *
506 * Here are wrapper functors for Boolean operations: @c &&, @c ||,
507 * and @c !.
508 *
509 * @{
510 */
511#if __cplusplus > 201103L
512 template<typename _Tp = void>
513 struct logical_and;
514
515 template<typename _Tp = void>
516 struct logical_or;
517
518 template<typename _Tp = void>
519 struct logical_not;
520#endif
521
522 /// One of the @link logical_functors Boolean operations functors@endlink.
523 template<typename _Tp>
524 struct logical_and : public binary_function<_Tp, _Tp, bool>
525 {
526 _GLIBCXX14_CONSTEXPR
527 bool
528 operator()(const _Tp& __x, const _Tp& __y) const
529 { return __x && __y; }
530 };
531
532 /// One of the @link logical_functors Boolean operations functors@endlink.
533 template<typename _Tp>
534 struct logical_or : public binary_function<_Tp, _Tp, bool>
535 {
536 _GLIBCXX14_CONSTEXPR
537 bool
538 operator()(const _Tp& __x, const _Tp& __y) const
539 { return __x || __y; }
540 };
541
542 /// One of the @link logical_functors Boolean operations functors@endlink.
543 template<typename _Tp>
544 struct logical_not : public unary_function<_Tp, bool>
545 {
546 _GLIBCXX14_CONSTEXPR
547 bool
548 operator()(const _Tp& __x) const
549 { return !__x; }
550 };
551
552#if __cplusplus > 201103L
553 /// One of the @link logical_functors Boolean operations functors@endlink.
554 template<>
556 {
557 template <typename _Tp, typename _Up>
558 _GLIBCXX14_CONSTEXPR
559 auto
560 operator()(_Tp&& __t, _Up&& __u) const
561 noexcept(noexcept(std::forward<_Tp>(__t) && std::forward<_Up>(__u)))
562 -> decltype(std::forward<_Tp>(__t) && std::forward<_Up>(__u))
563 { return std::forward<_Tp>(__t) && std::forward<_Up>(__u); }
564
566 };
567
568 /// One of the @link logical_functors Boolean operations functors@endlink.
569 template<>
571 {
572 template <typename _Tp, typename _Up>
573 _GLIBCXX14_CONSTEXPR
574 auto
575 operator()(_Tp&& __t, _Up&& __u) const
576 noexcept(noexcept(std::forward<_Tp>(__t) || std::forward<_Up>(__u)))
577 -> decltype(std::forward<_Tp>(__t) || std::forward<_Up>(__u))
578 { return std::forward<_Tp>(__t) || std::forward<_Up>(__u); }
579
581 };
582
583 /// One of the @link logical_functors Boolean operations functors@endlink.
584 template<>
586 {
587 template <typename _Tp>
588 _GLIBCXX14_CONSTEXPR
589 auto
590 operator()(_Tp&& __t) const
591 noexcept(noexcept(!std::forward<_Tp>(__t)))
592 -> decltype(!std::forward<_Tp>(__t))
593 { return !std::forward<_Tp>(__t); }
594
596 };
597#endif
598 /** @} */
599
600#if __cplusplus > 201103L
601 template<typename _Tp = void>
602 struct bit_and;
603
604 template<typename _Tp = void>
605 struct bit_or;
606
607 template<typename _Tp = void>
608 struct bit_xor;
609
610 template<typename _Tp = void>
611 struct bit_not;
612#endif
613
614 // _GLIBCXX_RESOLVE_LIB_DEFECTS
615 // DR 660. Missing Bitwise Operations.
616 template<typename _Tp>
617 struct bit_and : public binary_function<_Tp, _Tp, _Tp>
618 {
619 _GLIBCXX14_CONSTEXPR
620 _Tp
621 operator()(const _Tp& __x, const _Tp& __y) const
622 { return __x & __y; }
623 };
624
625 template<typename _Tp>
626 struct bit_or : public binary_function<_Tp, _Tp, _Tp>
627 {
628 _GLIBCXX14_CONSTEXPR
629 _Tp
630 operator()(const _Tp& __x, const _Tp& __y) const
631 { return __x | __y; }
632 };
633
634 template<typename _Tp>
635 struct bit_xor : public binary_function<_Tp, _Tp, _Tp>
636 {
637 _GLIBCXX14_CONSTEXPR
638 _Tp
639 operator()(const _Tp& __x, const _Tp& __y) const
640 { return __x ^ __y; }
641 };
642
643 template<typename _Tp>
644 struct bit_not : public unary_function<_Tp, _Tp>
645 {
646 _GLIBCXX14_CONSTEXPR
647 _Tp
648 operator()(const _Tp& __x) const
649 { return ~__x; }
650 };
651
652#if __cplusplus > 201103L
653 template <>
654 struct bit_and<void>
655 {
656 template <typename _Tp, typename _Up>
657 _GLIBCXX14_CONSTEXPR
658 auto
659 operator()(_Tp&& __t, _Up&& __u) const
660 noexcept(noexcept(std::forward<_Tp>(__t) & std::forward<_Up>(__u)))
661 -> decltype(std::forward<_Tp>(__t) & std::forward<_Up>(__u))
662 { return std::forward<_Tp>(__t) & std::forward<_Up>(__u); }
663
664 typedef __is_transparent is_transparent;
665 };
666
667 template <>
668 struct bit_or<void>
669 {
670 template <typename _Tp, typename _Up>
671 _GLIBCXX14_CONSTEXPR
672 auto
673 operator()(_Tp&& __t, _Up&& __u) const
674 noexcept(noexcept(std::forward<_Tp>(__t) | std::forward<_Up>(__u)))
675 -> decltype(std::forward<_Tp>(__t) | std::forward<_Up>(__u))
676 { return std::forward<_Tp>(__t) | std::forward<_Up>(__u); }
677
678 typedef __is_transparent is_transparent;
679 };
680
681 template <>
682 struct bit_xor<void>
683 {
684 template <typename _Tp, typename _Up>
685 _GLIBCXX14_CONSTEXPR
686 auto
687 operator()(_Tp&& __t, _Up&& __u) const
688 noexcept(noexcept(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u)))
689 -> decltype(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u))
690 { return std::forward<_Tp>(__t) ^ std::forward<_Up>(__u); }
691
692 typedef __is_transparent is_transparent;
693 };
694
695 template <>
696 struct bit_not<void>
697 {
698 template <typename _Tp>
699 _GLIBCXX14_CONSTEXPR
700 auto
701 operator()(_Tp&& __t) const
702 noexcept(noexcept(~std::forward<_Tp>(__t)))
703 -> decltype(~std::forward<_Tp>(__t))
704 { return ~std::forward<_Tp>(__t); }
705
706 typedef __is_transparent is_transparent;
707 };
708#endif
709
710 // 20.3.5 negators
711 /** @defgroup negators Negators
712 * @ingroup functors
713 *
714 * The functions @c not1 and @c not2 each take a predicate functor
715 * and return an instance of @c unary_negate or
716 * @c binary_negate, respectively. These classes are functors whose
717 * @c operator() performs the stored predicate function and then returns
718 * the negation of the result.
719 *
720 * For example, given a vector of integers and a trivial predicate,
721 * \code
722 * struct IntGreaterThanThree
723 * : public std::unary_function<int, bool>
724 * {
725 * bool operator() (int x) { return x > 3; }
726 * };
727 *
728 * std::find_if (v.begin(), v.end(), not1(IntGreaterThanThree()));
729 * \endcode
730 * The call to @c find_if will locate the first index (i) of @c v for which
731 * <code>!(v[i] > 3)</code> is true.
732 *
733 * The not1/unary_negate combination works on predicates taking a single
734 * argument. The not2/binary_negate combination works on predicates which
735 * take two arguments.
736 *
737 * @{
738 */
739 /// One of the @link negators negation functors@endlink.
740 template<typename _Predicate>
742 : public unary_function<typename _Predicate::argument_type, bool>
743 {
744 protected:
745 _Predicate _M_pred;
746
747 public:
748 _GLIBCXX14_CONSTEXPR
749 explicit
750 unary_negate(const _Predicate& __x) : _M_pred(__x) { }
751
752 _GLIBCXX14_CONSTEXPR
753 bool
754 operator()(const typename _Predicate::argument_type& __x) const
755 { return !_M_pred(__x); }
756 };
757
758 /// One of the @link negators negation functors@endlink.
759 template<typename _Predicate>
760 _GLIBCXX14_CONSTEXPR
762 not1(const _Predicate& __pred)
764
765 /// One of the @link negators negation functors@endlink.
766 template<typename _Predicate>
768 : public binary_function<typename _Predicate::first_argument_type,
769 typename _Predicate::second_argument_type, bool>
770 {
771 protected:
772 _Predicate _M_pred;
773
774 public:
775 _GLIBCXX14_CONSTEXPR
776 explicit
777 binary_negate(const _Predicate& __x) : _M_pred(__x) { }
778
779 _GLIBCXX14_CONSTEXPR
780 bool
781 operator()(const typename _Predicate::first_argument_type& __x,
782 const typename _Predicate::second_argument_type& __y) const
783 { return !_M_pred(__x, __y); }
784 };
785
786 /// One of the @link negators negation functors@endlink.
787 template<typename _Predicate>
788 _GLIBCXX14_CONSTEXPR
790 not2(const _Predicate& __pred)
792 /** @} */
793
794 // 20.3.7 adaptors pointers functions
795 /** @defgroup pointer_adaptors Adaptors for pointers to functions
796 * @ingroup functors
797 *
798 * The advantage of function objects over pointers to functions is that
799 * the objects in the standard library declare nested typedefs describing
800 * their argument and result types with uniform names (e.g., @c result_type
801 * from the base classes @c unary_function and @c binary_function).
802 * Sometimes those typedefs are required, not just optional.
803 *
804 * Adaptors are provided to turn pointers to unary (single-argument) and
805 * binary (double-argument) functions into function objects. The
806 * long-winded functor @c pointer_to_unary_function is constructed with a
807 * function pointer @c f, and its @c operator() called with argument @c x
808 * returns @c f(x). The functor @c pointer_to_binary_function does the same
809 * thing, but with a double-argument @c f and @c operator().
810 *
811 * The function @c ptr_fun takes a pointer-to-function @c f and constructs
812 * an instance of the appropriate functor.
813 *
814 * @{
815 */
816 /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
817 template<typename _Arg, typename _Result>
818 class pointer_to_unary_function : public unary_function<_Arg, _Result>
819 {
820 protected:
821 _Result (*_M_ptr)(_Arg);
822
823 public:
825
826 explicit
827 pointer_to_unary_function(_Result (*__x)(_Arg))
828 : _M_ptr(__x) { }
829
830 _Result
831 operator()(_Arg __x) const
832 { return _M_ptr(__x); }
833 };
834
835 /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
836 template<typename _Arg, typename _Result>
838 ptr_fun(_Result (*__x)(_Arg))
840
841 /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
842 template<typename _Arg1, typename _Arg2, typename _Result>
844 : public binary_function<_Arg1, _Arg2, _Result>
845 {
846 protected:
847 _Result (*_M_ptr)(_Arg1, _Arg2);
848
849 public:
851
852 explicit
853 pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
854 : _M_ptr(__x) { }
855
856 _Result
857 operator()(_Arg1 __x, _Arg2 __y) const
858 { return _M_ptr(__x, __y); }
859 };
860
861 /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
862 template<typename _Arg1, typename _Arg2, typename _Result>
866 /** @} */
867
868 template<typename _Tp>
869 struct _Identity
870 : public unary_function<_Tp,_Tp>
871 {
872 _Tp&
873 operator()(_Tp& __x) const
874 { return __x; }
875
876 const _Tp&
877 operator()(const _Tp& __x) const
878 { return __x; }
879 };
880
881 template<typename _Pair>
882 struct _Select1st
883 : public unary_function<_Pair, typename _Pair::first_type>
884 {
885 typename _Pair::first_type&
886 operator()(_Pair& __x) const
887 { return __x.first; }
888
889 const typename _Pair::first_type&
890 operator()(const _Pair& __x) const
891 { return __x.first; }
892
893#if __cplusplus >= 201103L
894 template<typename _Pair2>
895 typename _Pair2::first_type&
896 operator()(_Pair2& __x) const
897 { return __x.first; }
898
899 template<typename _Pair2>
900 const typename _Pair2::first_type&
901 operator()(const _Pair2& __x) const
902 { return __x.first; }
903#endif
904 };
905
906 template<typename _Pair>
907 struct _Select2nd
908 : public unary_function<_Pair, typename _Pair::second_type>
909 {
910 typename _Pair::second_type&
911 operator()(_Pair& __x) const
912 { return __x.second; }
913
914 const typename _Pair::second_type&
915 operator()(const _Pair& __x) const
916 { return __x.second; }
917 };
918
919 // 20.3.8 adaptors pointers members
920 /** @defgroup memory_adaptors Adaptors for pointers to members
921 * @ingroup functors
922 *
923 * There are a total of 8 = 2^3 function objects in this family.
924 * (1) Member functions taking no arguments vs member functions taking
925 * one argument.
926 * (2) Call through pointer vs call through reference.
927 * (3) Const vs non-const member function.
928 *
929 * All of this complexity is in the function objects themselves. You can
930 * ignore it by using the helper function mem_fun and mem_fun_ref,
931 * which create whichever type of adaptor is appropriate.
932 *
933 * @{
934 */
935 /// One of the @link memory_adaptors adaptors for member
936 /// pointers@endlink.
937 template<typename _Ret, typename _Tp>
938 class mem_fun_t : public unary_function<_Tp*, _Ret>
939 {
940 public:
941 explicit
942 mem_fun_t(_Ret (_Tp::*__pf)())
943 : _M_f(__pf) { }
944
945 _Ret
946 operator()(_Tp* __p) const
947 { return (__p->*_M_f)(); }
948
949 private:
950 _Ret (_Tp::*_M_f)();
951 };
952
953 /// One of the @link memory_adaptors adaptors for member
954 /// pointers@endlink.
955 template<typename _Ret, typename _Tp>
956 class const_mem_fun_t : public unary_function<const _Tp*, _Ret>
957 {
958 public:
959 explicit
960 const_mem_fun_t(_Ret (_Tp::*__pf)() const)
961 : _M_f(__pf) { }
962
963 _Ret
964 operator()(const _Tp* __p) const
965 { return (__p->*_M_f)(); }
966
967 private:
968 _Ret (_Tp::*_M_f)() const;
969 };
970
971 /// One of the @link memory_adaptors adaptors for member
972 /// pointers@endlink.
973 template<typename _Ret, typename _Tp>
974 class mem_fun_ref_t : public unary_function<_Tp, _Ret>
975 {
976 public:
977 explicit
978 mem_fun_ref_t(_Ret (_Tp::*__pf)())
979 : _M_f(__pf) { }
980
981 _Ret
982 operator()(_Tp& __r) const
983 { return (__r.*_M_f)(); }
984
985 private:
986 _Ret (_Tp::*_M_f)();
987 };
988
989 /// One of the @link memory_adaptors adaptors for member
990 /// pointers@endlink.
991 template<typename _Ret, typename _Tp>
992 class const_mem_fun_ref_t : public unary_function<_Tp, _Ret>
993 {
994 public:
995 explicit
996 const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const)
997 : _M_f(__pf) { }
998
999 _Ret
1000 operator()(const _Tp& __r) const
1001 { return (__r.*_M_f)(); }
1002
1003 private:
1004 _Ret (_Tp::*_M_f)() const;
1005 };
1006
1007 /// One of the @link memory_adaptors adaptors for member
1008 /// pointers@endlink.
1009 template<typename _Ret, typename _Tp, typename _Arg>
1010 class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret>
1011 {
1012 public:
1013 explicit
1014 mem_fun1_t(_Ret (_Tp::*__pf)(_Arg))
1015 : _M_f(__pf) { }
1016
1017 _Ret
1018 operator()(_Tp* __p, _Arg __x) const
1019 { return (__p->*_M_f)(__x); }
1020
1021 private:
1022 _Ret (_Tp::*_M_f)(_Arg);
1023 };
1024
1025 /// One of the @link memory_adaptors adaptors for member
1026 /// pointers@endlink.
1027 template<typename _Ret, typename _Tp, typename _Arg>
1028 class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret>
1029 {
1030 public:
1031 explicit
1032 const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const)
1033 : _M_f(__pf) { }
1034
1035 _Ret
1036 operator()(const _Tp* __p, _Arg __x) const
1037 { return (__p->*_M_f)(__x); }
1038
1039 private:
1040 _Ret (_Tp::*_M_f)(_Arg) const;
1041 };
1042
1043 /// One of the @link memory_adaptors adaptors for member
1044 /// pointers@endlink.
1045 template<typename _Ret, typename _Tp, typename _Arg>
1046 class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
1047 {
1048 public:
1049 explicit
1050 mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg))
1051 : _M_f(__pf) { }
1052
1053 _Ret
1054 operator()(_Tp& __r, _Arg __x) const
1055 { return (__r.*_M_f)(__x); }
1056
1057 private:
1058 _Ret (_Tp::*_M_f)(_Arg);
1059 };
1060
1061 /// One of the @link memory_adaptors adaptors for member
1062 /// pointers@endlink.
1063 template<typename _Ret, typename _Tp, typename _Arg>
1064 class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
1065 {
1066 public:
1067 explicit
1068 const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const)
1069 : _M_f(__pf) { }
1070
1071 _Ret
1072 operator()(const _Tp& __r, _Arg __x) const
1073 { return (__r.*_M_f)(__x); }
1074
1075 private:
1076 _Ret (_Tp::*_M_f)(_Arg) const;
1077 };
1078
1079 // Mem_fun adaptor helper functions. There are only two:
1080 // mem_fun and mem_fun_ref.
1081 template<typename _Ret, typename _Tp>
1083 mem_fun(_Ret (_Tp::*__f)())
1084 { return mem_fun_t<_Ret, _Tp>(__f); }
1085
1086 template<typename _Ret, typename _Tp>
1087 inline const_mem_fun_t<_Ret, _Tp>
1088 mem_fun(_Ret (_Tp::*__f)() const)
1089 { return const_mem_fun_t<_Ret, _Tp>(__f); }
1090
1091 template<typename _Ret, typename _Tp>
1092 inline mem_fun_ref_t<_Ret, _Tp>
1093 mem_fun_ref(_Ret (_Tp::*__f)())
1094 { return mem_fun_ref_t<_Ret, _Tp>(__f); }
1095
1096 template<typename _Ret, typename _Tp>
1097 inline const_mem_fun_ref_t<_Ret, _Tp>
1098 mem_fun_ref(_Ret (_Tp::*__f)() const)
1099 { return const_mem_fun_ref_t<_Ret, _Tp>(__f); }
1100
1101 template<typename _Ret, typename _Tp, typename _Arg>
1102 inline mem_fun1_t<_Ret, _Tp, _Arg>
1103 mem_fun(_Ret (_Tp::*__f)(_Arg))
1104 { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
1105
1106 template<typename _Ret, typename _Tp, typename _Arg>
1107 inline const_mem_fun1_t<_Ret, _Tp, _Arg>
1108 mem_fun(_Ret (_Tp::*__f)(_Arg) const)
1109 { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
1110
1111 template<typename _Ret, typename _Tp, typename _Arg>
1112 inline mem_fun1_ref_t<_Ret, _Tp, _Arg>
1113 mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
1114 { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
1115
1116 template<typename _Ret, typename _Tp, typename _Arg>
1117 inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
1118 mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
1119 { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
1120
1121 /** @} */
1122
1123_GLIBCXX_END_NAMESPACE_VERSION
1124} // namespace
1125
1126#if (__cplusplus < 201103L) || _GLIBCXX_USE_DEPRECATED
1127# include <backward/binders.h>
1128#endif
1129
1130#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.
_Arg argument_type
argument_type is the type of the argument
_Result result_type
result_type is the return type
_Result result_type
result_type is the return type
_Arg2 second_argument_type
second_argument_type is the type of the second argument
_Arg1 first_argument_type
first_argument_type is the type of the first argument
One of the math functors.
One of the math functors.
One of the math functors.
One of the math functors.
One of the math functors.
One of the math functors.
One of the comparison functors.
One of the comparison functors.
One of the comparison functors.
One of the comparison functors.
One of the comparison functors.
One of the comparison functors.
One of the Boolean operations functors.
One of the Boolean operations functors.
One of the Boolean operations functors.
One of the negation functors.
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.