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