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