1// Functor implementations -*- C++ -*-
2
3// Copyright (C) 2001-2014 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>
105 struct unary_function
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>
118 struct binary_function
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 _Tp
170 operator()(const _Tp& __x, const _Tp& __y) const
171 { return __x + __y; }
172 };
173
174 /// One of the @link arithmetic_functors math functors@endlink.
175 template<typename _Tp>
176 struct minus : public binary_function<_Tp, _Tp, _Tp>
177 {
178 _Tp
179 operator()(const _Tp& __x, const _Tp& __y) const
180 { return __x - __y; }
181 };
182
183 /// One of the @link arithmetic_functors math functors@endlink.
184 template<typename _Tp>
185 struct multiplies : public binary_function<_Tp, _Tp, _Tp>
186 {
187 _Tp
188 operator()(const _Tp& __x, const _Tp& __y) const
189 { return __x * __y; }
190 };
191
192 /// One of the @link arithmetic_functors math functors@endlink.
193 template<typename _Tp>
194 struct divides : public binary_function<_Tp, _Tp, _Tp>
195 {
196 _Tp
197 operator()(const _Tp& __x, const _Tp& __y) const
198 { return __x / __y; }
199 };
200
201 /// One of the @link arithmetic_functors math functors@endlink.
202 template<typename _Tp>
203 struct modulus : public binary_function<_Tp, _Tp, _Tp>
204 {
205 _Tp
206 operator()(const _Tp& __x, const _Tp& __y) const
207 { return __x % __y; }
208 };
209
210 /// One of the @link arithmetic_functors math functors@endlink.
211 template<typename _Tp>
212 struct negate : public unary_function<_Tp, _Tp>
213 {
214 _Tp
215 operator()(const _Tp& __x) const
216 { return -__x; }
217 };
218
219#if __cplusplus > 201103L
220 template<>
221 struct plus<void>
222 {
223 template <typename _Tp, typename _Up>
224 auto
225 operator()(_Tp&& __t, _Up&& __u) const
226 noexcept(noexcept(std::forward<_Tp>(__t) + std::forward<_Up>(__u)))
227 -> decltype(std::forward<_Tp>(__t) + std::forward<_Up>(__u))
228 { return std::forward<_Tp>(__t) + std::forward<_Up>(__u); }
229
230 typedef __is_transparent is_transparent;
231 };
232
233 /// One of the @link arithmetic_functors math functors@endlink.
234 template<>
235 struct minus<void>
236 {
237 template <typename _Tp, typename _Up>
238 auto
239 operator()(_Tp&& __t, _Up&& __u) const
240 noexcept(noexcept(std::forward<_Tp>(__t) - std::forward<_Up>(__u)))
241 -> decltype(std::forward<_Tp>(__t) - std::forward<_Up>(__u))
242 { return std::forward<_Tp>(__t) - std::forward<_Up>(__u); }
243
244 typedef __is_transparent is_transparent;
245 };
246
247 /// One of the @link arithmetic_functors math functors@endlink.
248 template<>
249 struct multiplies<void>
250 {
251 template <typename _Tp, typename _Up>
252 auto
253 operator()(_Tp&& __t, _Up&& __u) const
254 noexcept(noexcept(std::forward<_Tp>(__t) * std::forward<_Up>(__u)))
255 -> decltype(std::forward<_Tp>(__t) * std::forward<_Up>(__u))
256 { return std::forward<_Tp>(__t) * std::forward<_Up>(__u); }
257
258 typedef __is_transparent is_transparent;
259 };
260
261 /// One of the @link arithmetic_functors math functors@endlink.
262 template<>
263 struct divides<void>
264 {
265 template <typename _Tp, typename _Up>
266 auto
267 operator()(_Tp&& __t, _Up&& __u) const
268 noexcept(noexcept(std::forward<_Tp>(__t) / std::forward<_Up>(__u)))
269 -> decltype(std::forward<_Tp>(__t) / std::forward<_Up>(__u))
270 { return std::forward<_Tp>(__t) / std::forward<_Up>(__u); }
271
272 typedef __is_transparent is_transparent;
273 };
274
275 /// One of the @link arithmetic_functors math functors@endlink.
276 template<>
277 struct modulus<void>
278 {
279 template <typename _Tp, typename _Up>
280 auto
281 operator()(_Tp&& __t, _Up&& __u) const
282 noexcept(noexcept(std::forward<_Tp>(__t) % std::forward<_Up>(__u)))
283 -> decltype(std::forward<_Tp>(__t) % std::forward<_Up>(__u))
284 { return std::forward<_Tp>(__t) % std::forward<_Up>(__u); }
285
286 typedef __is_transparent is_transparent;
287 };
288
289 /// One of the @link arithmetic_functors math functors@endlink.
290 template<>
291 struct negate<void>
292 {
293 template <typename _Tp>
294 auto
295 operator()(_Tp&& __t) const
296 noexcept(noexcept(-std::forward<_Tp>(__t)))
297 -> decltype(-std::forward<_Tp>(__t))
298 { return -std::forward<_Tp>(__t); }
299
300 typedef __is_transparent is_transparent;
301 };
302#endif
303 /** @} */
304
305 // 20.3.3 comparisons
306 /** @defgroup comparison_functors Comparison Classes
307 * @ingroup functors
308 *
309 * The library provides six wrapper functors for all the basic comparisons
310 * in C++, like @c <.
311 *
312 * @{
313 */
314#if __cplusplus > 201103L
315 template<typename _Tp = void>
316 struct equal_to;
317
318 template<typename _Tp = void>
319 struct not_equal_to;
320
321 template<typename _Tp = void>
322 struct greater;
323
324 template<typename _Tp = void>
325 struct less;
326
327 template<typename _Tp = void>
328 struct greater_equal;
329
330 template<typename _Tp = void>
331 struct less_equal;
332#endif
333
334 /// One of the @link comparison_functors comparison functors@endlink.
335 template<typename _Tp>
336 struct equal_to : public binary_function<_Tp, _Tp, bool>
337 {
338 bool
339 operator()(const _Tp& __x, const _Tp& __y) const
340 { return __x == __y; }
341 };
342
343 /// One of the @link comparison_functors comparison functors@endlink.
344 template<typename _Tp>
345 struct not_equal_to : public binary_function<_Tp, _Tp, bool>
346 {
347 bool
348 operator()(const _Tp& __x, const _Tp& __y) const
349 { return __x != __y; }
350 };
351
352 /// One of the @link comparison_functors comparison functors@endlink.
353 template<typename _Tp>
354 struct greater : public binary_function<_Tp, _Tp, bool>
355 {
356 bool
357 operator()(const _Tp& __x, const _Tp& __y) const
358 { return __x > __y; }
359 };
360
361 /// One of the @link comparison_functors comparison functors@endlink.
362 template<typename _Tp>
363 struct less : public binary_function<_Tp, _Tp, bool>
364 {
365 bool
366 operator()(const _Tp& __x, const _Tp& __y) const
367 { return __x < __y; }
368 };
369
370 /// One of the @link comparison_functors comparison functors@endlink.
371 template<typename _Tp>
372 struct greater_equal : public binary_function<_Tp, _Tp, bool>
373 {
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_equal : public binary_function<_Tp, _Tp, bool>
382 {
383 bool
384 operator()(const _Tp& __x, const _Tp& __y) const
385 { return __x <= __y; }
386 };
387
388#if __cplusplus > 201103L
389 /// One of the @link comparison_functors comparison functors@endlink.
390 template<>
391 struct equal_to<void>
392 {
393 template <typename _Tp, typename _Up>
394 auto
395 operator()(_Tp&& __t, _Up&& __u) const
396 noexcept(noexcept(std::forward<_Tp>(__t) == std::forward<_Up>(__u)))
397 -> decltype(std::forward<_Tp>(__t) == std::forward<_Up>(__u))
398 { return std::forward<_Tp>(__t) == std::forward<_Up>(__u); }
399
400 typedef __is_transparent is_transparent;
401 };
402
403 /// One of the @link comparison_functors comparison functors@endlink.
404 template<>
405 struct not_equal_to<void>
406 {
407 template <typename _Tp, typename _Up>
408 auto
409 operator()(_Tp&& __t, _Up&& __u) const
410 noexcept(noexcept(std::forward<_Tp>(__t) != std::forward<_Up>(__u)))
411 -> decltype(std::forward<_Tp>(__t) != std::forward<_Up>(__u))
412 { return std::forward<_Tp>(__t) != std::forward<_Up>(__u); }
413
414 typedef __is_transparent is_transparent;
415 };
416
417 /// One of the @link comparison_functors comparison functors@endlink.
418 template<>
419 struct greater<void>
420 {
421 template <typename _Tp, typename _Up>
422 auto
423 operator()(_Tp&& __t, _Up&& __u) const
424 noexcept(noexcept(std::forward<_Tp>(__t) > std::forward<_Up>(__u)))
425 -> decltype(std::forward<_Tp>(__t) > std::forward<_Up>(__u))
426 { return std::forward<_Tp>(__t) > std::forward<_Up>(__u); }
427
428 typedef __is_transparent is_transparent;
429 };
430
431 /// One of the @link comparison_functors comparison functors@endlink.
432 template<>
433 struct less<void>
434 {
435 template <typename _Tp, typename _Up>
436 auto
437 operator()(_Tp&& __t, _Up&& __u) const
438 noexcept(noexcept(std::forward<_Tp>(__t) < std::forward<_Up>(__u)))
439 -> decltype(std::forward<_Tp>(__t) < std::forward<_Up>(__u))
440 { return std::forward<_Tp>(__t) < std::forward<_Up>(__u); }
441
442 typedef __is_transparent is_transparent;
443 };
444
445 /// One of the @link comparison_functors comparison functors@endlink.
446 template<>
447 struct greater_equal<void>
448 {
449 template <typename _Tp, typename _Up>
450 auto
451 operator()(_Tp&& __t, _Up&& __u) const
452 noexcept(noexcept(std::forward<_Tp>(__t) >= std::forward<_Up>(__u)))
453 -> decltype(std::forward<_Tp>(__t) >= std::forward<_Up>(__u))
454 { return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); }
455
456 typedef __is_transparent is_transparent;
457 };
458
459 /// One of the @link comparison_functors comparison functors@endlink.
460 template<>
461 struct less_equal<void>
462 {
463 template <typename _Tp, typename _Up>
464 auto
465 operator()(_Tp&& __t, _Up&& __u) const
466 noexcept(noexcept(std::forward<_Tp>(__t) <= std::forward<_Up>(__u)))
467 -> decltype(std::forward<_Tp>(__t) <= std::forward<_Up>(__u))
468 { return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); }
469
470 typedef __is_transparent is_transparent;
471 };
472#endif
473 /** @} */
474
475 // 20.3.4 logical operations
476 /** @defgroup logical_functors Boolean Operations Classes
477 * @ingroup functors
478 *
479 * Here are wrapper functors for Boolean operations: @c &&, @c ||,
480 * and @c !.
481 *
482 * @{
483 */
484#if __cplusplus > 201103L
485 template<typename _Tp = void>
486 struct logical_and;
487
488 template<typename _Tp = void>
489 struct logical_or;
490
491 template<typename _Tp = void>
492 struct logical_not;
493#endif
494
495 /// One of the @link logical_functors Boolean operations functors@endlink.
496 template<typename _Tp>
497 struct logical_and : public binary_function<_Tp, _Tp, bool>
498 {
499 bool
500 operator()(const _Tp& __x, const _Tp& __y) const
501 { return __x && __y; }
502 };
503
504 /// One of the @link logical_functors Boolean operations functors@endlink.
505 template<typename _Tp>
506 struct logical_or : public binary_function<_Tp, _Tp, bool>
507 {
508 bool
509 operator()(const _Tp& __x, const _Tp& __y) const
510 { return __x || __y; }
511 };
512
513 /// One of the @link logical_functors Boolean operations functors@endlink.
514 template<typename _Tp>
515 struct logical_not : public unary_function<_Tp, bool>
516 {
517 bool
518 operator()(const _Tp& __x) const
519 { return !__x; }
520 };
521
522#if __cplusplus > 201103L
523 /// One of the @link logical_functors Boolean operations functors@endlink.
524 template<>
525 struct logical_and<void>
526 {
527 template <typename _Tp, typename _Up>
528 auto
529 operator()(_Tp&& __t, _Up&& __u) const
530 noexcept(noexcept(std::forward<_Tp>(__t) && std::forward<_Up>(__u)))
531 -> decltype(std::forward<_Tp>(__t) && std::forward<_Up>(__u))
532 { return std::forward<_Tp>(__t) && std::forward<_Up>(__u); }
533
534 typedef __is_transparent is_transparent;
535 };
536
537 /// One of the @link logical_functors Boolean operations functors@endlink.
538 template<>
539 struct logical_or<void>
540 {
541 template <typename _Tp, typename _Up>
542 auto
543 operator()(_Tp&& __t, _Up&& __u) const
544 noexcept(noexcept(std::forward<_Tp>(__t) || std::forward<_Up>(__u)))
545 -> decltype(std::forward<_Tp>(__t) || std::forward<_Up>(__u))
546 { return std::forward<_Tp>(__t) || std::forward<_Up>(__u); }
547
548 typedef __is_transparent is_transparent;
549 };
550
551 /// One of the @link logical_functors Boolean operations functors@endlink.
552 template<>
553 struct logical_not<void>
554 {
555 template <typename _Tp>
556 auto
557 operator()(_Tp&& __t) const
558 noexcept(noexcept(!std::forward<_Tp>(__t)))
559 -> decltype(!std::forward<_Tp>(__t))
560 { return !std::forward<_Tp>(__t); }
561
562 typedef __is_transparent is_transparent;
563 };
564#endif
565 /** @} */
566
567#if __cplusplus > 201103L
568 template<typename _Tp = void>
569 struct bit_and;
570
571 template<typename _Tp = void>
572 struct bit_or;
573
574 template<typename _Tp = void>
575 struct bit_xor;
576
577 template<typename _Tp = void>
578 struct bit_not;
579#endif
580
581 // _GLIBCXX_RESOLVE_LIB_DEFECTS
582 // DR 660. Missing Bitwise Operations.
583 template<typename _Tp>
584 struct bit_and : public binary_function<_Tp, _Tp, _Tp>
585 {
586 _Tp
587 operator()(const _Tp& __x, const _Tp& __y) const
588 { return __x & __y; }
589 };
590
591 template<typename _Tp>
592 struct bit_or : public binary_function<_Tp, _Tp, _Tp>
593 {
594 _Tp
595 operator()(const _Tp& __x, const _Tp& __y) const
596 { return __x | __y; }
597 };
598
599 template<typename _Tp>
600 struct bit_xor : public binary_function<_Tp, _Tp, _Tp>
601 {
602 _Tp
603 operator()(const _Tp& __x, const _Tp& __y) const
604 { return __x ^ __y; }
605 };
606
607 template<typename _Tp>
608 struct bit_not : public unary_function<_Tp, _Tp>
609 {
610 _Tp
611 operator()(const _Tp& __x) const
612 { return ~__x; }
613 };
614
615#if __cplusplus > 201103L
616 template <>
617 struct bit_and<void>
618 {
619 template <typename _Tp, typename _Up>
620 auto
621 operator()(_Tp&& __t, _Up&& __u) const
622 noexcept(noexcept(std::forward<_Tp>(__t) & std::forward<_Up>(__u)))
623 -> decltype(std::forward<_Tp>(__t) & std::forward<_Up>(__u))
624 { return std::forward<_Tp>(__t) & std::forward<_Up>(__u); }
625
626 typedef __is_transparent is_transparent;
627 };
628
629 template <>
630 struct bit_or<void>
631 {
632 template <typename _Tp, typename _Up>
633 auto
634 operator()(_Tp&& __t, _Up&& __u) const
635 noexcept(noexcept(std::forward<_Tp>(__t) | std::forward<_Up>(__u)))
636 -> decltype(std::forward<_Tp>(__t) | std::forward<_Up>(__u))
637 { return std::forward<_Tp>(__t) | std::forward<_Up>(__u); }
638
639 typedef __is_transparent is_transparent;
640 };
641
642 template <>
643 struct bit_xor<void>
644 {
645 template <typename _Tp, typename _Up>
646 auto
647 operator()(_Tp&& __t, _Up&& __u) const
648 noexcept(noexcept(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u)))
649 -> decltype(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u))
650 { return std::forward<_Tp>(__t) ^ std::forward<_Up>(__u); }
651
652 typedef __is_transparent is_transparent;
653 };
654
655 template <>
656 struct bit_not<void>
657 {
658 template <typename _Tp>
659 auto
660 operator()(_Tp&& __t) const
661 noexcept(noexcept(~std::forward<_Tp>(__t)))
662 -> decltype(~std::forward<_Tp>(__t))
663 { return ~std::forward<_Tp>(__t); }
664
665 typedef __is_transparent is_transparent;
666 };
667#endif
668
669 // 20.3.5 negators
670 /** @defgroup negators Negators
671 * @ingroup functors
672 *
673 * The functions @c not1 and @c not2 each take a predicate functor
674 * and return an instance of @c unary_negate or
675 * @c binary_negate, respectively. These classes are functors whose
676 * @c operator() performs the stored predicate function and then returns
677 * the negation of the result.
678 *
679 * For example, given a vector of integers and a trivial predicate,
680 * \code
681 * struct IntGreaterThanThree
682 * : public std::unary_function<int, bool>
683 * {
684 * bool operator() (int x) { return x > 3; }
685 * };
686 *
687 * std::find_if (v.begin(), v.end(), not1(IntGreaterThanThree()));
688 * \endcode
689 * The call to @c find_if will locate the first index (i) of @c v for which
690 * <code>!(v[i] > 3)</code> is true.
691 *
692 * The not1/unary_negate combination works on predicates taking a single
693 * argument. The not2/binary_negate combination works on predicates which
694 * take two arguments.
695 *
696 * @{
697 */
698 /// One of the @link negators negation functors@endlink.
699 template<typename _Predicate>
700 class unary_negate
701 : public unary_function<typename _Predicate::argument_type, bool>
702 {
703 protected:
704 _Predicate _M_pred;
705
706 public:
707 explicit
708 unary_negate(const _Predicate& __x) : _M_pred(__x) { }
709
710 bool
711 operator()(const typename _Predicate::argument_type& __x) const
712 { return !_M_pred(__x); }
713 };
714
715 /// One of the @link negators negation functors@endlink.
716 template<typename _Predicate>
717 inline unary_negate<_Predicate>
718 not1(const _Predicate& __pred)
719 { return unary_negate<_Predicate>(__pred); }
720
721 /// One of the @link negators negation functors@endlink.
722 template<typename _Predicate>
723 class binary_negate
724 : public binary_function<typename _Predicate::first_argument_type,
725 typename _Predicate::second_argument_type, bool>
726 {
727 protected:
728 _Predicate _M_pred;
729
730 public:
731 explicit
732 binary_negate(const _Predicate& __x) : _M_pred(__x) { }
733
734 bool
735 operator()(const typename _Predicate::first_argument_type& __x,
736 const typename _Predicate::second_argument_type& __y) const
737 { return !_M_pred(__x, __y); }
738 };
739
740 /// One of the @link negators negation functors@endlink.
741 template<typename _Predicate>
742 inline binary_negate<_Predicate>
743 not2(const _Predicate& __pred)
744 { return binary_negate<_Predicate>(__pred); }
745 /** @} */
746
747 // 20.3.7 adaptors pointers functions
748 /** @defgroup pointer_adaptors Adaptors for pointers to functions
749 * @ingroup functors
750 *
751 * The advantage of function objects over pointers to functions is that
752 * the objects in the standard library declare nested typedefs describing
753 * their argument and result types with uniform names (e.g., @c result_type
754 * from the base classes @c unary_function and @c binary_function).
755 * Sometimes those typedefs are required, not just optional.
756 *
757 * Adaptors are provided to turn pointers to unary (single-argument) and
758 * binary (double-argument) functions into function objects. The
759 * long-winded functor @c pointer_to_unary_function is constructed with a
760 * function pointer @c f, and its @c operator() called with argument @c x
761 * returns @c f(x). The functor @c pointer_to_binary_function does the same
762 * thing, but with a double-argument @c f and @c operator().
763 *
764 * The function @c ptr_fun takes a pointer-to-function @c f and constructs
765 * an instance of the appropriate functor.
766 *
767 * @{
768 */
769 /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
770 template<typename _Arg, typename _Result>
771 class pointer_to_unary_function : public unary_function<_Arg, _Result>
772 {
773 protected:
774 _Result (*_M_ptr)(_Arg);
775
776 public:
777 pointer_to_unary_function() { }
778
779 explicit
780 pointer_to_unary_function(_Result (*__x)(_Arg))
781 : _M_ptr(__x) { }
782
783 _Result
784 operator()(_Arg __x) const
785 { return _M_ptr(__x); }
786 };
787
788 /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
789 template<typename _Arg, typename _Result>
790 inline pointer_to_unary_function<_Arg, _Result>
791 ptr_fun(_Result (*__x)(_Arg))
792 { return pointer_to_unary_function<_Arg, _Result>(__x); }
793
794 /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
795 template<typename _Arg1, typename _Arg2, typename _Result>
796 class pointer_to_binary_function
797 : public binary_function<_Arg1, _Arg2, _Result>
798 {
799 protected:
800 _Result (*_M_ptr)(_Arg1, _Arg2);
801
802 public:
803 pointer_to_binary_function() { }
804
805 explicit
806 pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
807 : _M_ptr(__x) { }
808
809 _Result
810 operator()(_Arg1 __x, _Arg2 __y) const
811 { return _M_ptr(__x, __y); }
812 };
813
814 /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
815 template<typename _Arg1, typename _Arg2, typename _Result>
816 inline pointer_to_binary_function<_Arg1, _Arg2, _Result>
817 ptr_fun(_Result (*__x)(_Arg1, _Arg2))
818 { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); }
819 /** @} */
820
821 template<typename _Tp>
822 struct _Identity
823 : public unary_function<_Tp,_Tp>
824 {
825 _Tp&
826 operator()(_Tp& __x) const
827 { return __x; }
828
829 const _Tp&
830 operator()(const _Tp& __x) const
831 { return __x; }
832 };
833
834 template<typename _Pair>
835 struct _Select1st
836 : public unary_function<_Pair, typename _Pair::first_type>
837 {
838 typename _Pair::first_type&
839 operator()(_Pair& __x) const
840 { return __x.first; }
841
842 const typename _Pair::first_type&
843 operator()(const _Pair& __x) const
844 { return __x.first; }
845
846#if __cplusplus >= 201103L
847 template<typename _Pair2>
848 typename _Pair2::first_type&
849 operator()(_Pair2& __x) const
850 { return __x.first; }
851
852 template<typename _Pair2>
853 const typename _Pair2::first_type&
854 operator()(const _Pair2& __x) const
855 { return __x.first; }
856#endif
857 };
858
859 template<typename _Pair>
860 struct _Select2nd
861 : public unary_function<_Pair, typename _Pair::second_type>
862 {
863 typename _Pair::second_type&
864 operator()(_Pair& __x) const
865 { return __x.second; }
866
867 const typename _Pair::second_type&
868 operator()(const _Pair& __x) const
869 { return __x.second; }
870 };
871
872 // 20.3.8 adaptors pointers members
873 /** @defgroup memory_adaptors Adaptors for pointers to members
874 * @ingroup functors
875 *
876 * There are a total of 8 = 2^3 function objects in this family.
877 * (1) Member functions taking no arguments vs member functions taking
878 * one argument.
879 * (2) Call through pointer vs call through reference.
880 * (3) Const vs non-const member function.
881 *
882 * All of this complexity is in the function objects themselves. You can
883 * ignore it by using the helper function mem_fun and mem_fun_ref,
884 * which create whichever type of adaptor is appropriate.
885 *
886 * @{
887 */
888 /// One of the @link memory_adaptors adaptors for member
889 /// pointers@endlink.
890 template<typename _Ret, typename _Tp>
891 class mem_fun_t : public unary_function<_Tp*, _Ret>
892 {
893 public:
894 explicit
895 mem_fun_t(_Ret (_Tp::*__pf)())
896 : _M_f(__pf) { }
897
898 _Ret
899 operator()(_Tp* __p) const
900 { return (__p->*_M_f)(); }
901
902 private:
903 _Ret (_Tp::*_M_f)();
904 };
905
906 /// One of the @link memory_adaptors adaptors for member
907 /// pointers@endlink.
908 template<typename _Ret, typename _Tp>
909 class const_mem_fun_t : public unary_function<const _Tp*, _Ret>
910 {
911 public:
912 explicit
913 const_mem_fun_t(_Ret (_Tp::*__pf)() const)
914 : _M_f(__pf) { }
915
916 _Ret
917 operator()(const _Tp* __p) const
918 { return (__p->*_M_f)(); }
919
920 private:
921 _Ret (_Tp::*_M_f)() const;
922 };
923
924 /// One of the @link memory_adaptors adaptors for member
925 /// pointers@endlink.
926 template<typename _Ret, typename _Tp>
927 class mem_fun_ref_t : public unary_function<_Tp, _Ret>
928 {
929 public:
930 explicit
931 mem_fun_ref_t(_Ret (_Tp::*__pf)())
932 : _M_f(__pf) { }
933
934 _Ret
935 operator()(_Tp& __r) const
936 { return (__r.*_M_f)(); }
937
938 private:
939 _Ret (_Tp::*_M_f)();
940 };
941
942 /// One of the @link memory_adaptors adaptors for member
943 /// pointers@endlink.
944 template<typename _Ret, typename _Tp>
945 class const_mem_fun_ref_t : public unary_function<_Tp, _Ret>
946 {
947 public:
948 explicit
949 const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const)
950 : _M_f(__pf) { }
951
952 _Ret
953 operator()(const _Tp& __r) const
954 { return (__r.*_M_f)(); }
955
956 private:
957 _Ret (_Tp::*_M_f)() const;
958 };
959
960 /// One of the @link memory_adaptors adaptors for member
961 /// pointers@endlink.
962 template<typename _Ret, typename _Tp, typename _Arg>
963 class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret>
964 {
965 public:
966 explicit
967 mem_fun1_t(_Ret (_Tp::*__pf)(_Arg))
968 : _M_f(__pf) { }
969
970 _Ret
971 operator()(_Tp* __p, _Arg __x) const
972 { return (__p->*_M_f)(__x); }
973
974 private:
975 _Ret (_Tp::*_M_f)(_Arg);
976 };
977
978 /// One of the @link memory_adaptors adaptors for member
979 /// pointers@endlink.
980 template<typename _Ret, typename _Tp, typename _Arg>
981 class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret>
982 {
983 public:
984 explicit
985 const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const)
986 : _M_f(__pf) { }
987
988 _Ret
989 operator()(const _Tp* __p, _Arg __x) const
990 { return (__p->*_M_f)(__x); }
991
992 private:
993 _Ret (_Tp::*_M_f)(_Arg) const;
994 };
995
996 /// One of the @link memory_adaptors adaptors for member
997 /// pointers@endlink.
998 template<typename _Ret, typename _Tp, typename _Arg>
999 class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
1000 {
1001 public:
1002 explicit
1003 mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg))
1004 : _M_f(__pf) { }
1005
1006 _Ret
1007 operator()(_Tp& __r, _Arg __x) const
1008 { return (__r.*_M_f)(__x); }
1009
1010 private:
1011 _Ret (_Tp::*_M_f)(_Arg);
1012 };
1013
1014 /// One of the @link memory_adaptors adaptors for member
1015 /// pointers@endlink.
1016 template<typename _Ret, typename _Tp, typename _Arg>
1017 class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
1018 {
1019 public:
1020 explicit
1021 const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const)
1022 : _M_f(__pf) { }
1023
1024 _Ret
1025 operator()(const _Tp& __r, _Arg __x) const
1026 { return (__r.*_M_f)(__x); }
1027
1028 private:
1029 _Ret (_Tp::*_M_f)(_Arg) const;
1030 };
1031
1032 // Mem_fun adaptor helper functions. There are only two:
1033 // mem_fun and mem_fun_ref.
1034 template<typename _Ret, typename _Tp>
1035 inline mem_fun_t<_Ret, _Tp>
1036 mem_fun(_Ret (_Tp::*__f)())
1037 { return mem_fun_t<_Ret, _Tp>(__f); }
1038
1039 template<typename _Ret, typename _Tp>
1040 inline const_mem_fun_t<_Ret, _Tp>
1041 mem_fun(_Ret (_Tp::*__f)() const)
1042 { return const_mem_fun_t<_Ret, _Tp>(__f); }
1043
1044 template<typename _Ret, typename _Tp>
1045 inline mem_fun_ref_t<_Ret, _Tp>
1046 mem_fun_ref(_Ret (_Tp::*__f)())
1047 { return mem_fun_ref_t<_Ret, _Tp>(__f); }
1048
1049 template<typename _Ret, typename _Tp>
1050 inline const_mem_fun_ref_t<_Ret, _Tp>
1051 mem_fun_ref(_Ret (_Tp::*__f)() const)
1052 { return const_mem_fun_ref_t<_Ret, _Tp>(__f); }
1053
1054 template<typename _Ret, typename _Tp, typename _Arg>
1055 inline mem_fun1_t<_Ret, _Tp, _Arg>
1056 mem_fun(_Ret (_Tp::*__f)(_Arg))
1057 { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
1058
1059 template<typename _Ret, typename _Tp, typename _Arg>
1060 inline const_mem_fun1_t<_Ret, _Tp, _Arg>
1061 mem_fun(_Ret (_Tp::*__f)(_Arg) const)
1062 { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
1063
1064 template<typename _Ret, typename _Tp, typename _Arg>
1065 inline mem_fun1_ref_t<_Ret, _Tp, _Arg>
1066 mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
1067 { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
1068
1069 template<typename _Ret, typename _Tp, typename _Arg>
1070 inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
1071 mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
1072 { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
1073
1074 /** @} */
1075
1076_GLIBCXX_END_NAMESPACE_VERSION
1077} // namespace
1078
1079#if (__cplusplus < 201103L) || _GLIBCXX_USE_DEPRECATED
1080# include <backward/binders.h>
1081#endif
1082
1083#endif /* _STL_FUNCTION_H */
1084