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