libstdc++
stl_function.h
Go to the documentation of this file.
1 // Functor implementations -*- C++ -*-
2 
3 // Copyright (C) 2001-2021 Free Software Foundation, Inc.
4 //
5 // This file is part of the GNU ISO C++ Library. This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 3, or (at your option)
9 // any later version.
10 
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
15 
16 // Under Section 7 of GPL version 3, you are granted additional
17 // permissions described in the GCC Runtime Library Exception, version
18 // 3.1, as published by the Free Software Foundation.
19 
20 // You should have received a copy of the GNU General Public License and
21 // a copy of the GCC Runtime Library Exception along with this program;
22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 // <http://www.gnu.org/licenses/>.
24 
25 /*
26  *
27  * Copyright (c) 1994
28  * Hewlett-Packard Company
29  *
30  * Permission to use, copy, modify, distribute and sell this software
31  * and its documentation for any purpose is hereby granted without fee,
32  * provided that the above copyright notice appear in all copies and
33  * that both that copyright notice and this permission notice appear
34  * in supporting documentation. Hewlett-Packard Company makes no
35  * representations about the suitability of this software for any
36  * purpose. It is provided "as is" without express or implied warranty.
37  *
38  *
39  * Copyright (c) 1996-1998
40  * Silicon Graphics Computer Systems, Inc.
41  *
42  * Permission to use, copy, modify, distribute and sell this software
43  * and its documentation for any purpose is hereby granted without fee,
44  * provided that the above copyright notice appear in all copies and
45  * that both that copyright notice and this permission notice appear
46  * in supporting documentation. Silicon Graphics makes no
47  * representations about the suitability of this software for any
48  * purpose. It is provided "as is" without express or implied warranty.
49  */
50 
51 /** @file bits/stl_function.h
52  * This is an internal header file, included by other library headers.
53  * Do not attempt to use it directly. @headername{functional}
54  */
55 
56 #ifndef _STL_FUNCTION_H
57 #define _STL_FUNCTION_H 1
58 
59 #if __cplusplus > 201103L
60 #include <bits/move.h>
61 #endif
62 
63 namespace std _GLIBCXX_VISIBILITY(default)
64 {
65 _GLIBCXX_BEGIN_NAMESPACE_VERSION
66 
67  // 20.3.1 base classes
68  /** @defgroup functors Function Objects
69  * @ingroup utilities
70  *
71  * Function objects, or @e functors, are objects with an @c operator()
72  * defined and accessible. They can be passed as arguments to algorithm
73  * templates and used in place of a function pointer. Not only is the
74  * resulting expressiveness of the library increased, but the generated
75  * code can be more efficient than what you might write by hand. When we
76  * refer to @a functors, then, generally we include function pointers in
77  * the description as well.
78  *
79  * Often, functors are only created as temporaries passed to algorithm
80  * calls, rather than being created as named variables.
81  *
82  * Two examples taken from the standard itself follow. To perform a
83  * by-element addition of two vectors @c a and @c b containing @c double,
84  * and put the result in @c a, use
85  * \code
86  * transform (a.begin(), a.end(), b.begin(), a.begin(), plus<double>());
87  * \endcode
88  * To negate every element in @c a, use
89  * \code
90  * transform(a.begin(), a.end(), a.begin(), negate<double>());
91  * \endcode
92  * The addition and negation functions will be inlined directly.
93  *
94  * The standard functors are derived from structs named @c unary_function
95  * and @c binary_function. These two classes contain nothing but typedefs,
96  * to aid in generic (template) programming. If you write your own
97  * functors, you might consider doing the same.
98  *
99  * @{
100  */
101  /**
102  * This is one of the @link functors functor base classes@endlink.
103  */
104  template<typename _Arg, typename _Result>
106  {
107  /// @c argument_type is the type of the argument
108  typedef _Arg argument_type;
109 
110  /// @c result_type is the return type
111  typedef _Result result_type;
112  };
113 
114  /**
115  * This is one of the @link functors functor base classes@endlink.
116  */
117  template<typename _Arg1, typename _Arg2, typename _Result>
119  {
120  /// @c first_argument_type is the type of the first argument
121  typedef _Arg1 first_argument_type;
122 
123  /// @c second_argument_type is the type of the second argument
124  typedef _Arg2 second_argument_type;
125 
126  /// @c result_type is the return type
127  typedef _Result result_type;
128  };
129  /** @} */
130 
131  // 20.3.2 arithmetic
132  /** @defgroup arithmetic_functors Arithmetic Classes
133  * @ingroup functors
134  *
135  * Because basic math often needs to be done during an algorithm,
136  * the library provides functors for those operations. See the
137  * documentation for @link functors the base classes@endlink
138  * for examples of their use.
139  *
140  * @{
141  */
142 
143 #if __cplusplus > 201103L
144  struct __is_transparent; // undefined
145 
146  template<typename _Tp = void>
147  struct plus;
148 
149  template<typename _Tp = void>
150  struct minus;
151 
152  template<typename _Tp = void>
153  struct multiplies;
154 
155  template<typename _Tp = void>
156  struct divides;
157 
158  template<typename _Tp = void>
159  struct modulus;
160 
161  template<typename _Tp = void>
162  struct negate;
163 #endif
164 
165  /// One of the @link arithmetic_functors math functors@endlink.
166  template<typename _Tp>
167  struct plus : public binary_function<_Tp, _Tp, _Tp>
168  {
169  _GLIBCXX14_CONSTEXPR
170  _Tp
171  operator()(const _Tp& __x, const _Tp& __y) const
172  { return __x + __y; }
173  };
174 
175  /// One of the @link arithmetic_functors math functors@endlink.
176  template<typename _Tp>
177  struct minus : public binary_function<_Tp, _Tp, _Tp>
178  {
179  _GLIBCXX14_CONSTEXPR
180  _Tp
181  operator()(const _Tp& __x, const _Tp& __y) const
182  { return __x - __y; }
183  };
184 
185  /// One of the @link arithmetic_functors math functors@endlink.
186  template<typename _Tp>
187  struct multiplies : public binary_function<_Tp, _Tp, _Tp>
188  {
189  _GLIBCXX14_CONSTEXPR
190  _Tp
191  operator()(const _Tp& __x, const _Tp& __y) const
192  { return __x * __y; }
193  };
194 
195  /// One of the @link arithmetic_functors math functors@endlink.
196  template<typename _Tp>
197  struct divides : public binary_function<_Tp, _Tp, _Tp>
198  {
199  _GLIBCXX14_CONSTEXPR
200  _Tp
201  operator()(const _Tp& __x, const _Tp& __y) const
202  { return __x / __y; }
203  };
204 
205  /// One of the @link arithmetic_functors math functors@endlink.
206  template<typename _Tp>
207  struct modulus : public binary_function<_Tp, _Tp, _Tp>
208  {
209  _GLIBCXX14_CONSTEXPR
210  _Tp
211  operator()(const _Tp& __x, const _Tp& __y) const
212  { return __x % __y; }
213  };
214 
215  /// One of the @link arithmetic_functors math functors@endlink.
216  template<typename _Tp>
217  struct negate : public unary_function<_Tp, _Tp>
218  {
219  _GLIBCXX14_CONSTEXPR
220  _Tp
221  operator()(const _Tp& __x) const
222  { return -__x; }
223  };
224 
225 #if __cplusplus > 201103L
226 
227 #define __cpp_lib_transparent_operators 201510
228 
229  template<>
230  struct plus<void>
231  {
232  template <typename _Tp, typename _Up>
233  _GLIBCXX14_CONSTEXPR
234  auto
235  operator()(_Tp&& __t, _Up&& __u) const
236  noexcept(noexcept(std::forward<_Tp>(__t) + std::forward<_Up>(__u)))
237  -> decltype(std::forward<_Tp>(__t) + std::forward<_Up>(__u))
238  { return std::forward<_Tp>(__t) + std::forward<_Up>(__u); }
239 
240  typedef __is_transparent is_transparent;
241  };
242 
243  /// One of the @link arithmetic_functors math functors@endlink.
244  template<>
245  struct minus<void>
246  {
247  template <typename _Tp, typename _Up>
248  _GLIBCXX14_CONSTEXPR
249  auto
250  operator()(_Tp&& __t, _Up&& __u) const
251  noexcept(noexcept(std::forward<_Tp>(__t) - std::forward<_Up>(__u)))
252  -> decltype(std::forward<_Tp>(__t) - std::forward<_Up>(__u))
253  { return std::forward<_Tp>(__t) - std::forward<_Up>(__u); }
254 
255  typedef __is_transparent is_transparent;
256  };
257 
258  /// One of the @link arithmetic_functors math functors@endlink.
259  template<>
260  struct multiplies<void>
261  {
262  template <typename _Tp, typename _Up>
263  _GLIBCXX14_CONSTEXPR
264  auto
265  operator()(_Tp&& __t, _Up&& __u) const
266  noexcept(noexcept(std::forward<_Tp>(__t) * std::forward<_Up>(__u)))
267  -> decltype(std::forward<_Tp>(__t) * std::forward<_Up>(__u))
268  { return std::forward<_Tp>(__t) * std::forward<_Up>(__u); }
269 
270  typedef __is_transparent is_transparent;
271  };
272 
273  /// One of the @link arithmetic_functors math functors@endlink.
274  template<>
275  struct divides<void>
276  {
277  template <typename _Tp, typename _Up>
278  _GLIBCXX14_CONSTEXPR
279  auto
280  operator()(_Tp&& __t, _Up&& __u) const
281  noexcept(noexcept(std::forward<_Tp>(__t) / std::forward<_Up>(__u)))
282  -> decltype(std::forward<_Tp>(__t) / std::forward<_Up>(__u))
283  { return std::forward<_Tp>(__t) / std::forward<_Up>(__u); }
284 
285  typedef __is_transparent is_transparent;
286  };
287 
288  /// One of the @link arithmetic_functors math functors@endlink.
289  template<>
290  struct modulus<void>
291  {
292  template <typename _Tp, typename _Up>
293  _GLIBCXX14_CONSTEXPR
294  auto
295  operator()(_Tp&& __t, _Up&& __u) const
296  noexcept(noexcept(std::forward<_Tp>(__t) % std::forward<_Up>(__u)))
297  -> decltype(std::forward<_Tp>(__t) % std::forward<_Up>(__u))
298  { return std::forward<_Tp>(__t) % std::forward<_Up>(__u); }
299 
300  typedef __is_transparent is_transparent;
301  };
302 
303  /// One of the @link arithmetic_functors math functors@endlink.
304  template<>
305  struct negate<void>
306  {
307  template <typename _Tp>
308  _GLIBCXX14_CONSTEXPR
309  auto
310  operator()(_Tp&& __t) const
311  noexcept(noexcept(-std::forward<_Tp>(__t)))
312  -> decltype(-std::forward<_Tp>(__t))
313  { return -std::forward<_Tp>(__t); }
314 
315  typedef __is_transparent is_transparent;
316  };
317 #endif
318  /** @} */
319 
320  // 20.3.3 comparisons
321  /** @defgroup comparison_functors Comparison Classes
322  * @ingroup functors
323  *
324  * The library provides six wrapper functors for all the basic comparisons
325  * in C++, like @c <.
326  *
327  * @{
328  */
329 #if __cplusplus > 201103L
330  template<typename _Tp = void>
331  struct equal_to;
332 
333  template<typename _Tp = void>
334  struct not_equal_to;
335 
336  template<typename _Tp = void>
337  struct greater;
338 
339  template<typename _Tp = void>
340  struct less;
341 
342  template<typename _Tp = void>
343  struct greater_equal;
344 
345  template<typename _Tp = void>
346  struct less_equal;
347 #endif
348 
349  /// One of the @link comparison_functors comparison functors@endlink.
350  template<typename _Tp>
351  struct equal_to : public binary_function<_Tp, _Tp, bool>
352  {
353  _GLIBCXX14_CONSTEXPR
354  bool
355  operator()(const _Tp& __x, const _Tp& __y) const
356  { return __x == __y; }
357  };
358 
359  /// One of the @link comparison_functors comparison functors@endlink.
360  template<typename _Tp>
361  struct not_equal_to : public binary_function<_Tp, _Tp, bool>
362  {
363  _GLIBCXX14_CONSTEXPR
364  bool
365  operator()(const _Tp& __x, const _Tp& __y) const
366  { return __x != __y; }
367  };
368 
369  /// One of the @link comparison_functors comparison functors@endlink.
370  template<typename _Tp>
371  struct greater : public binary_function<_Tp, _Tp, bool>
372  {
373  _GLIBCXX14_CONSTEXPR
374  bool
375  operator()(const _Tp& __x, const _Tp& __y) const
376  { return __x > __y; }
377  };
378 
379  /// One of the @link comparison_functors comparison functors@endlink.
380  template<typename _Tp>
381  struct less : public binary_function<_Tp, _Tp, bool>
382  {
383  _GLIBCXX14_CONSTEXPR
384  bool
385  operator()(const _Tp& __x, const _Tp& __y) const
386  { return __x < __y; }
387  };
388 
389  /// One of the @link comparison_functors comparison functors@endlink.
390  template<typename _Tp>
391  struct greater_equal : public binary_function<_Tp, _Tp, bool>
392  {
393  _GLIBCXX14_CONSTEXPR
394  bool
395  operator()(const _Tp& __x, const _Tp& __y) const
396  { return __x >= __y; }
397  };
398 
399  /// One of the @link comparison_functors comparison functors@endlink.
400  template<typename _Tp>
401  struct less_equal : public binary_function<_Tp, _Tp, bool>
402  {
403  _GLIBCXX14_CONSTEXPR
404  bool
405  operator()(const _Tp& __x, const _Tp& __y) const
406  { return __x <= __y; }
407  };
408 
409  // Partial specialization of std::greater for pointers.
410  template<typename _Tp>
411  struct greater<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
412  {
413  _GLIBCXX14_CONSTEXPR bool
414  operator()(_Tp* __x, _Tp* __y) const _GLIBCXX_NOTHROW
415  {
416 #if __cplusplus >= 201402L
417 #ifdef _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED
418  if (__builtin_is_constant_evaluated())
419 #else
420  if (__builtin_constant_p(__x > __y))
421 #endif
422  return __x > __y;
423 #endif
424  return (__UINTPTR_TYPE__)__x > (__UINTPTR_TYPE__)__y;
425  }
426  };
427 
428  // Partial specialization of std::less for pointers.
429  template<typename _Tp>
430  struct less<_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 #ifdef _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED
437  if (__builtin_is_constant_evaluated())
438 #else
439  if (__builtin_constant_p(__x < __y))
440 #endif
441  return __x < __y;
442 #endif
443  return (__UINTPTR_TYPE__)__x < (__UINTPTR_TYPE__)__y;
444  }
445  };
446 
447  // Partial specialization of std::greater_equal for pointers.
448  template<typename _Tp>
449  struct greater_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
450  {
451  _GLIBCXX14_CONSTEXPR bool
452  operator()(_Tp* __x, _Tp* __y) const _GLIBCXX_NOTHROW
453  {
454 #if __cplusplus >= 201402L
455 #ifdef _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED
456  if (__builtin_is_constant_evaluated())
457 #else
458  if (__builtin_constant_p(__x >= __y))
459 #endif
460  return __x >= __y;
461 #endif
462  return (__UINTPTR_TYPE__)__x >= (__UINTPTR_TYPE__)__y;
463  }
464  };
465 
466  // Partial specialization of std::less_equal for pointers.
467  template<typename _Tp>
468  struct less_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
469  {
470  _GLIBCXX14_CONSTEXPR bool
471  operator()(_Tp* __x, _Tp* __y) const _GLIBCXX_NOTHROW
472  {
473 #if __cplusplus >= 201402L
474 #ifdef _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED
475  if (__builtin_is_constant_evaluated())
476 #else
477  if (__builtin_constant_p(__x <= __y))
478 #endif
479  return __x <= __y;
480 #endif
481  return (__UINTPTR_TYPE__)__x <= (__UINTPTR_TYPE__)__y;
482  }
483  };
484 
485 #if __cplusplus >= 201402L
486  /// One of the @link comparison_functors comparison functors@endlink.
487  template<>
488  struct equal_to<void>
489  {
490  template <typename _Tp, typename _Up>
491  constexpr auto
492  operator()(_Tp&& __t, _Up&& __u) const
493  noexcept(noexcept(std::forward<_Tp>(__t) == std::forward<_Up>(__u)))
494  -> decltype(std::forward<_Tp>(__t) == std::forward<_Up>(__u))
495  { return std::forward<_Tp>(__t) == std::forward<_Up>(__u); }
496 
497  typedef __is_transparent is_transparent;
498  };
499 
500  /// One of the @link comparison_functors comparison functors@endlink.
501  template<>
502  struct not_equal_to<void>
503  {
504  template <typename _Tp, typename _Up>
505  constexpr auto
506  operator()(_Tp&& __t, _Up&& __u) const
507  noexcept(noexcept(std::forward<_Tp>(__t) != std::forward<_Up>(__u)))
508  -> decltype(std::forward<_Tp>(__t) != std::forward<_Up>(__u))
509  { return std::forward<_Tp>(__t) != std::forward<_Up>(__u); }
510 
511  typedef __is_transparent is_transparent;
512  };
513 
514  /// One of the @link comparison_functors comparison functors@endlink.
515  template<>
516  struct greater<void>
517  {
518  template <typename _Tp, typename _Up>
519  constexpr auto
520  operator()(_Tp&& __t, _Up&& __u) const
521  noexcept(noexcept(std::forward<_Tp>(__t) > std::forward<_Up>(__u)))
522  -> decltype(std::forward<_Tp>(__t) > std::forward<_Up>(__u))
523  {
524  return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
525  __ptr_cmp<_Tp, _Up>{});
526  }
527 
528  template<typename _Tp, typename _Up>
529  constexpr bool
530  operator()(_Tp* __t, _Up* __u) const noexcept
531  { return greater<common_type_t<_Tp*, _Up*>>{}(__t, __u); }
532 
533  typedef __is_transparent is_transparent;
534 
535  private:
536  template <typename _Tp, typename _Up>
537  static constexpr decltype(auto)
538  _S_cmp(_Tp&& __t, _Up&& __u, false_type)
539  { return std::forward<_Tp>(__t) > std::forward<_Up>(__u); }
540 
541  template <typename _Tp, typename _Up>
542  static constexpr bool
543  _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
544  {
546  static_cast<const volatile void*>(std::forward<_Tp>(__t)),
547  static_cast<const volatile void*>(std::forward<_Up>(__u)));
548  }
549 
550  // True if there is no viable operator> member function.
551  template<typename _Tp, typename _Up, typename = void>
552  struct __not_overloaded2 : true_type { };
553 
554  // False if we can call T.operator>(U)
555  template<typename _Tp, typename _Up>
556  struct __not_overloaded2<_Tp, _Up, __void_t<
557  decltype(std::declval<_Tp>().operator>(std::declval<_Up>()))>>
558  : false_type { };
559 
560  // True if there is no overloaded operator> for these operands.
561  template<typename _Tp, typename _Up, typename = void>
562  struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };
563 
564  // False if we can call operator>(T,U)
565  template<typename _Tp, typename _Up>
566  struct __not_overloaded<_Tp, _Up, __void_t<
567  decltype(operator>(std::declval<_Tp>(), std::declval<_Up>()))>>
568  : false_type { };
569 
570  template<typename _Tp, typename _Up>
571  using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
574  };
575 
576  /// One of the @link comparison_functors comparison functors@endlink.
577  template<>
578  struct less<void>
579  {
580  template <typename _Tp, typename _Up>
581  constexpr auto
582  operator()(_Tp&& __t, _Up&& __u) const
583  noexcept(noexcept(std::forward<_Tp>(__t) < std::forward<_Up>(__u)))
584  -> decltype(std::forward<_Tp>(__t) < std::forward<_Up>(__u))
585  {
586  return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
587  __ptr_cmp<_Tp, _Up>{});
588  }
589 
590  template<typename _Tp, typename _Up>
591  constexpr bool
592  operator()(_Tp* __t, _Up* __u) const noexcept
593  { return less<common_type_t<_Tp*, _Up*>>{}(__t, __u); }
594 
595  typedef __is_transparent is_transparent;
596 
597  private:
598  template <typename _Tp, typename _Up>
599  static constexpr decltype(auto)
600  _S_cmp(_Tp&& __t, _Up&& __u, false_type)
601  { return std::forward<_Tp>(__t) < std::forward<_Up>(__u); }
602 
603  template <typename _Tp, typename _Up>
604  static constexpr bool
605  _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
606  {
608  static_cast<const volatile void*>(std::forward<_Tp>(__t)),
609  static_cast<const volatile void*>(std::forward<_Up>(__u)));
610  }
611 
612  // True if there is no viable operator< member function.
613  template<typename _Tp, typename _Up, typename = void>
614  struct __not_overloaded2 : true_type { };
615 
616  // False if we can call T.operator<(U)
617  template<typename _Tp, typename _Up>
618  struct __not_overloaded2<_Tp, _Up, __void_t<
619  decltype(std::declval<_Tp>().operator<(std::declval<_Up>()))>>
620  : false_type { };
621 
622  // True if there is no overloaded operator< for these operands.
623  template<typename _Tp, typename _Up, typename = void>
624  struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };
625 
626  // False if we can call operator<(T,U)
627  template<typename _Tp, typename _Up>
628  struct __not_overloaded<_Tp, _Up, __void_t<
629  decltype(operator<(std::declval<_Tp>(), std::declval<_Up>()))>>
630  : false_type { };
631 
632  template<typename _Tp, typename _Up>
633  using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
636  };
637 
638  /// One of the @link comparison_functors comparison functors@endlink.
639  template<>
640  struct greater_equal<void>
641  {
642  template <typename _Tp, typename _Up>
643  constexpr auto
644  operator()(_Tp&& __t, _Up&& __u) const
645  noexcept(noexcept(std::forward<_Tp>(__t) >= std::forward<_Up>(__u)))
646  -> decltype(std::forward<_Tp>(__t) >= std::forward<_Up>(__u))
647  {
648  return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
649  __ptr_cmp<_Tp, _Up>{});
650  }
651 
652  template<typename _Tp, typename _Up>
653  constexpr bool
654  operator()(_Tp* __t, _Up* __u) const noexcept
655  { return greater_equal<common_type_t<_Tp*, _Up*>>{}(__t, __u); }
656 
657  typedef __is_transparent is_transparent;
658 
659  private:
660  template <typename _Tp, typename _Up>
661  static constexpr decltype(auto)
662  _S_cmp(_Tp&& __t, _Up&& __u, false_type)
663  { return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); }
664 
665  template <typename _Tp, typename _Up>
666  static constexpr bool
667  _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
668  {
670  static_cast<const volatile void*>(std::forward<_Tp>(__t)),
671  static_cast<const volatile void*>(std::forward<_Up>(__u)));
672  }
673 
674  // True if there is no viable operator>= member function.
675  template<typename _Tp, typename _Up, typename = void>
676  struct __not_overloaded2 : true_type { };
677 
678  // False if we can call T.operator>=(U)
679  template<typename _Tp, typename _Up>
680  struct __not_overloaded2<_Tp, _Up, __void_t<
681  decltype(std::declval<_Tp>().operator>=(std::declval<_Up>()))>>
682  : false_type { };
683 
684  // True if there is no overloaded operator>= for these operands.
685  template<typename _Tp, typename _Up, typename = void>
686  struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };
687 
688  // False if we can call operator>=(T,U)
689  template<typename _Tp, typename _Up>
690  struct __not_overloaded<_Tp, _Up, __void_t<
691  decltype(operator>=(std::declval<_Tp>(), std::declval<_Up>()))>>
692  : false_type { };
693 
694  template<typename _Tp, typename _Up>
695  using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
698  };
699 
700  /// One of the @link comparison_functors comparison functors@endlink.
701  template<>
702  struct less_equal<void>
703  {
704  template <typename _Tp, typename _Up>
705  constexpr auto
706  operator()(_Tp&& __t, _Up&& __u) const
707  noexcept(noexcept(std::forward<_Tp>(__t) <= std::forward<_Up>(__u)))
708  -> decltype(std::forward<_Tp>(__t) <= std::forward<_Up>(__u))
709  {
710  return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
711  __ptr_cmp<_Tp, _Up>{});
712  }
713 
714  template<typename _Tp, typename _Up>
715  constexpr bool
716  operator()(_Tp* __t, _Up* __u) const noexcept
717  { return less_equal<common_type_t<_Tp*, _Up*>>{}(__t, __u); }
718 
719  typedef __is_transparent is_transparent;
720 
721  private:
722  template <typename _Tp, typename _Up>
723  static constexpr decltype(auto)
724  _S_cmp(_Tp&& __t, _Up&& __u, false_type)
725  { return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); }
726 
727  template <typename _Tp, typename _Up>
728  static constexpr bool
729  _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
730  {
732  static_cast<const volatile void*>(std::forward<_Tp>(__t)),
733  static_cast<const volatile void*>(std::forward<_Up>(__u)));
734  }
735 
736  // True if there is no viable operator<= member function.
737  template<typename _Tp, typename _Up, typename = void>
738  struct __not_overloaded2 : true_type { };
739 
740  // False if we can call T.operator<=(U)
741  template<typename _Tp, typename _Up>
742  struct __not_overloaded2<_Tp, _Up, __void_t<
743  decltype(std::declval<_Tp>().operator<=(std::declval<_Up>()))>>
744  : false_type { };
745 
746  // True if there is no overloaded operator<= for these operands.
747  template<typename _Tp, typename _Up, typename = void>
748  struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };
749 
750  // False if we can call operator<=(T,U)
751  template<typename _Tp, typename _Up>
752  struct __not_overloaded<_Tp, _Up, __void_t<
753  decltype(operator<=(std::declval<_Tp>(), std::declval<_Up>()))>>
754  : false_type { };
755 
756  template<typename _Tp, typename _Up>
757  using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
760  };
761 #endif // C++14
762  /** @} */
763 
764  // 20.3.4 logical operations
765  /** @defgroup logical_functors Boolean Operations Classes
766  * @ingroup functors
767  *
768  * Here are wrapper functors for Boolean operations: @c &&, @c ||,
769  * and @c !.
770  *
771  * @{
772  */
773 #if __cplusplus > 201103L
774  template<typename _Tp = void>
775  struct logical_and;
776 
777  template<typename _Tp = void>
778  struct logical_or;
779 
780  template<typename _Tp = void>
781  struct logical_not;
782 #endif
783 
784  /// One of the @link logical_functors Boolean operations functors@endlink.
785  template<typename _Tp>
786  struct logical_and : public binary_function<_Tp, _Tp, bool>
787  {
788  _GLIBCXX14_CONSTEXPR
789  bool
790  operator()(const _Tp& __x, const _Tp& __y) const
791  { return __x && __y; }
792  };
793 
794  /// One of the @link logical_functors Boolean operations functors@endlink.
795  template<typename _Tp>
796  struct logical_or : 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_not : public unary_function<_Tp, bool>
807  {
808  _GLIBCXX14_CONSTEXPR
809  bool
810  operator()(const _Tp& __x) const
811  { return !__x; }
812  };
813 
814 #if __cplusplus > 201103L
815  /// One of the @link logical_functors Boolean operations functors@endlink.
816  template<>
817  struct logical_and<void>
818  {
819  template <typename _Tp, typename _Up>
820  _GLIBCXX14_CONSTEXPR
821  auto
822  operator()(_Tp&& __t, _Up&& __u) const
823  noexcept(noexcept(std::forward<_Tp>(__t) && std::forward<_Up>(__u)))
824  -> decltype(std::forward<_Tp>(__t) && std::forward<_Up>(__u))
825  { return std::forward<_Tp>(__t) && std::forward<_Up>(__u); }
826 
827  typedef __is_transparent is_transparent;
828  };
829 
830  /// One of the @link logical_functors Boolean operations functors@endlink.
831  template<>
832  struct logical_or<void>
833  {
834  template <typename _Tp, typename _Up>
835  _GLIBCXX14_CONSTEXPR
836  auto
837  operator()(_Tp&& __t, _Up&& __u) const
838  noexcept(noexcept(std::forward<_Tp>(__t) || std::forward<_Up>(__u)))
839  -> decltype(std::forward<_Tp>(__t) || std::forward<_Up>(__u))
840  { return std::forward<_Tp>(__t) || std::forward<_Up>(__u); }
841 
842  typedef __is_transparent is_transparent;
843  };
844 
845  /// One of the @link logical_functors Boolean operations functors@endlink.
846  template<>
847  struct logical_not<void>
848  {
849  template <typename _Tp>
850  _GLIBCXX14_CONSTEXPR
851  auto
852  operator()(_Tp&& __t) const
853  noexcept(noexcept(!std::forward<_Tp>(__t)))
854  -> decltype(!std::forward<_Tp>(__t))
855  { return !std::forward<_Tp>(__t); }
856 
857  typedef __is_transparent is_transparent;
858  };
859 #endif
860  /** @} */
861 
862 #if __cplusplus > 201103L
863  template<typename _Tp = void>
864  struct bit_and;
865 
866  template<typename _Tp = void>
867  struct bit_or;
868 
869  template<typename _Tp = void>
870  struct bit_xor;
871 
872  template<typename _Tp = void>
873  struct bit_not;
874 #endif
875 
876  // _GLIBCXX_RESOLVE_LIB_DEFECTS
877  // DR 660. Missing Bitwise Operations.
878  template<typename _Tp>
879  struct bit_and : public binary_function<_Tp, _Tp, _Tp>
880  {
881  _GLIBCXX14_CONSTEXPR
882  _Tp
883  operator()(const _Tp& __x, const _Tp& __y) const
884  { return __x & __y; }
885  };
886 
887  template<typename _Tp>
888  struct bit_or : public binary_function<_Tp, _Tp, _Tp>
889  {
890  _GLIBCXX14_CONSTEXPR
891  _Tp
892  operator()(const _Tp& __x, const _Tp& __y) const
893  { return __x | __y; }
894  };
895 
896  template<typename _Tp>
897  struct bit_xor : public binary_function<_Tp, _Tp, _Tp>
898  {
899  _GLIBCXX14_CONSTEXPR
900  _Tp
901  operator()(const _Tp& __x, const _Tp& __y) const
902  { return __x ^ __y; }
903  };
904 
905  template<typename _Tp>
906  struct bit_not : public unary_function<_Tp, _Tp>
907  {
908  _GLIBCXX14_CONSTEXPR
909  _Tp
910  operator()(const _Tp& __x) const
911  { return ~__x; }
912  };
913 
914 #if __cplusplus > 201103L
915  template <>
916  struct bit_and<void>
917  {
918  template <typename _Tp, typename _Up>
919  _GLIBCXX14_CONSTEXPR
920  auto
921  operator()(_Tp&& __t, _Up&& __u) const
922  noexcept(noexcept(std::forward<_Tp>(__t) & std::forward<_Up>(__u)))
923  -> decltype(std::forward<_Tp>(__t) & std::forward<_Up>(__u))
924  { return std::forward<_Tp>(__t) & std::forward<_Up>(__u); }
925 
926  typedef __is_transparent is_transparent;
927  };
928 
929  template <>
930  struct bit_or<void>
931  {
932  template <typename _Tp, typename _Up>
933  _GLIBCXX14_CONSTEXPR
934  auto
935  operator()(_Tp&& __t, _Up&& __u) const
936  noexcept(noexcept(std::forward<_Tp>(__t) | std::forward<_Up>(__u)))
937  -> decltype(std::forward<_Tp>(__t) | std::forward<_Up>(__u))
938  { return std::forward<_Tp>(__t) | std::forward<_Up>(__u); }
939 
940  typedef __is_transparent is_transparent;
941  };
942 
943  template <>
944  struct bit_xor<void>
945  {
946  template <typename _Tp, typename _Up>
947  _GLIBCXX14_CONSTEXPR
948  auto
949  operator()(_Tp&& __t, _Up&& __u) const
950  noexcept(noexcept(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u)))
951  -> decltype(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u))
952  { return std::forward<_Tp>(__t) ^ std::forward<_Up>(__u); }
953 
954  typedef __is_transparent is_transparent;
955  };
956 
957  template <>
958  struct bit_not<void>
959  {
960  template <typename _Tp>
961  _GLIBCXX14_CONSTEXPR
962  auto
963  operator()(_Tp&& __t) const
964  noexcept(noexcept(~std::forward<_Tp>(__t)))
965  -> decltype(~std::forward<_Tp>(__t))
966  { return ~std::forward<_Tp>(__t); }
967 
968  typedef __is_transparent is_transparent;
969  };
970 #endif
971 
972  // 20.3.5 negators
973  /** @defgroup negators Negators
974  * @ingroup functors
975  *
976  * The functions @c not1 and @c not2 each take a predicate functor
977  * and return an instance of @c unary_negate or
978  * @c binary_negate, respectively. These classes are functors whose
979  * @c operator() performs the stored predicate function and then returns
980  * the negation of the result.
981  *
982  * For example, given a vector of integers and a trivial predicate,
983  * \code
984  * struct IntGreaterThanThree
985  * : public std::unary_function<int, bool>
986  * {
987  * bool operator() (int x) { return x > 3; }
988  * };
989  *
990  * std::find_if (v.begin(), v.end(), not1(IntGreaterThanThree()));
991  * \endcode
992  * The call to @c find_if will locate the first index (i) of @c v for which
993  * <code>!(v[i] > 3)</code> is true.
994  *
995  * The not1/unary_negate combination works on predicates taking a single
996  * argument. The not2/binary_negate combination works on predicates which
997  * take two arguments.
998  *
999  * @{
1000  */
1001  /// One of the @link negators negation functors@endlink.
1002  template<typename _Predicate>
1004  : public unary_function<typename _Predicate::argument_type, bool>
1005  {
1006  protected:
1007  _Predicate _M_pred;
1008 
1009  public:
1010  _GLIBCXX14_CONSTEXPR
1011  explicit
1012  unary_negate(const _Predicate& __x) : _M_pred(__x) { }
1013 
1014  _GLIBCXX14_CONSTEXPR
1015  bool
1016  operator()(const typename _Predicate::argument_type& __x) const
1017  { return !_M_pred(__x); }
1018  };
1019 
1020  /// One of the @link negators negation functors@endlink.
1021  template<typename _Predicate>
1022  _GLIBCXX14_CONSTEXPR
1024  not1(const _Predicate& __pred)
1025  { return unary_negate<_Predicate>(__pred); }
1026 
1027  /// One of the @link negators negation functors@endlink.
1028  template<typename _Predicate>
1030  : public binary_function<typename _Predicate::first_argument_type,
1031  typename _Predicate::second_argument_type, bool>
1032  {
1033  protected:
1034  _Predicate _M_pred;
1035 
1036  public:
1037  _GLIBCXX14_CONSTEXPR
1038  explicit
1039  binary_negate(const _Predicate& __x) : _M_pred(__x) { }
1040 
1041  _GLIBCXX14_CONSTEXPR
1042  bool
1043  operator()(const typename _Predicate::first_argument_type& __x,
1044  const typename _Predicate::second_argument_type& __y) const
1045  { return !_M_pred(__x, __y); }
1046  };
1047 
1048  /// One of the @link negators negation functors@endlink.
1049  template<typename _Predicate>
1050  _GLIBCXX14_CONSTEXPR
1052  not2(const _Predicate& __pred)
1053  { return binary_negate<_Predicate>(__pred); }
1054  /** @} */
1055 
1056  // 20.3.7 adaptors pointers functions
1057  /** @defgroup pointer_adaptors Adaptors for pointers to functions
1058  * @ingroup functors
1059  *
1060  * The advantage of function objects over pointers to functions is that
1061  * the objects in the standard library declare nested typedefs describing
1062  * their argument and result types with uniform names (e.g., @c result_type
1063  * from the base classes @c unary_function and @c binary_function).
1064  * Sometimes those typedefs are required, not just optional.
1065  *
1066  * Adaptors are provided to turn pointers to unary (single-argument) and
1067  * binary (double-argument) functions into function objects. The
1068  * long-winded functor @c pointer_to_unary_function is constructed with a
1069  * function pointer @c f, and its @c operator() called with argument @c x
1070  * returns @c f(x). The functor @c pointer_to_binary_function does the same
1071  * thing, but with a double-argument @c f and @c operator().
1072  *
1073  * The function @c ptr_fun takes a pointer-to-function @c f and constructs
1074  * an instance of the appropriate functor.
1075  *
1076  * @{
1077  */
1078  /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
1079  template<typename _Arg, typename _Result>
1080  class pointer_to_unary_function : public unary_function<_Arg, _Result>
1081  {
1082  protected:
1083  _Result (*_M_ptr)(_Arg);
1084 
1085  public:
1087 
1088  explicit
1089  pointer_to_unary_function(_Result (*__x)(_Arg))
1090  : _M_ptr(__x) { }
1091 
1092  _Result
1093  operator()(_Arg __x) const
1094  { return _M_ptr(__x); }
1095  };
1096 
1097  /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
1098  template<typename _Arg, typename _Result>
1100  ptr_fun(_Result (*__x)(_Arg))
1102 
1103  /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
1104  template<typename _Arg1, typename _Arg2, typename _Result>
1106  : public binary_function<_Arg1, _Arg2, _Result>
1107  {
1108  protected:
1109  _Result (*_M_ptr)(_Arg1, _Arg2);
1110 
1111  public:
1113 
1114  explicit
1115  pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
1116  : _M_ptr(__x) { }
1117 
1118  _Result
1119  operator()(_Arg1 __x, _Arg2 __y) const
1120  { return _M_ptr(__x, __y); }
1121  };
1122 
1123  /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
1124  template<typename _Arg1, typename _Arg2, typename _Result>
1126  ptr_fun(_Result (*__x)(_Arg1, _Arg2))
1128  /** @} */
1129 
1130  template<typename _Tp>
1131  struct _Identity
1132  : public unary_function<_Tp, _Tp>
1133  {
1134  _Tp&
1135  operator()(_Tp& __x) const
1136  { return __x; }
1137 
1138  const _Tp&
1139  operator()(const _Tp& __x) const
1140  { return __x; }
1141  };
1142 
1143  // Partial specialization, avoids confusing errors in e.g. std::set<const T>.
1144  template<typename _Tp> struct _Identity<const _Tp> : _Identity<_Tp> { };
1145 
1146  template<typename _Pair>
1147  struct _Select1st
1148  : public unary_function<_Pair, typename _Pair::first_type>
1149  {
1150  typename _Pair::first_type&
1151  operator()(_Pair& __x) const
1152  { return __x.first; }
1153 
1154  const typename _Pair::first_type&
1155  operator()(const _Pair& __x) const
1156  { return __x.first; }
1157 
1158 #if __cplusplus >= 201103L
1159  template<typename _Pair2>
1160  typename _Pair2::first_type&
1161  operator()(_Pair2& __x) const
1162  { return __x.first; }
1163 
1164  template<typename _Pair2>
1165  const typename _Pair2::first_type&
1166  operator()(const _Pair2& __x) const
1167  { return __x.first; }
1168 #endif
1169  };
1170 
1171  template<typename _Pair>
1172  struct _Select2nd
1173  : public unary_function<_Pair, typename _Pair::second_type>
1174  {
1175  typename _Pair::second_type&
1176  operator()(_Pair& __x) const
1177  { return __x.second; }
1178 
1179  const typename _Pair::second_type&
1180  operator()(const _Pair& __x) const
1181  { return __x.second; }
1182  };
1183 
1184  // 20.3.8 adaptors pointers members
1185  /** @defgroup memory_adaptors Adaptors for pointers to members
1186  * @ingroup functors
1187  *
1188  * There are a total of 8 = 2^3 function objects in this family.
1189  * (1) Member functions taking no arguments vs member functions taking
1190  * one argument.
1191  * (2) Call through pointer vs call through reference.
1192  * (3) Const vs non-const member function.
1193  *
1194  * All of this complexity is in the function objects themselves. You can
1195  * ignore it by using the helper function mem_fun and mem_fun_ref,
1196  * which create whichever type of adaptor is appropriate.
1197  *
1198  * @{
1199  */
1200  /// One of the @link memory_adaptors adaptors for member
1201  /// pointers@endlink.
1202  template<typename _Ret, typename _Tp>
1203  class mem_fun_t : public unary_function<_Tp*, _Ret>
1204  {
1205  public:
1206  explicit
1207  mem_fun_t(_Ret (_Tp::*__pf)())
1208  : _M_f(__pf) { }
1209 
1210  _Ret
1211  operator()(_Tp* __p) const
1212  { return (__p->*_M_f)(); }
1213 
1214  private:
1215  _Ret (_Tp::*_M_f)();
1216  };
1217 
1218  /// One of the @link memory_adaptors adaptors for member
1219  /// pointers@endlink.
1220  template<typename _Ret, typename _Tp>
1221  class const_mem_fun_t : public unary_function<const _Tp*, _Ret>
1222  {
1223  public:
1224  explicit
1225  const_mem_fun_t(_Ret (_Tp::*__pf)() const)
1226  : _M_f(__pf) { }
1227 
1228  _Ret
1229  operator()(const _Tp* __p) const
1230  { return (__p->*_M_f)(); }
1231 
1232  private:
1233  _Ret (_Tp::*_M_f)() const;
1234  };
1235 
1236  /// One of the @link memory_adaptors adaptors for member
1237  /// pointers@endlink.
1238  template<typename _Ret, typename _Tp>
1239  class mem_fun_ref_t : public unary_function<_Tp, _Ret>
1240  {
1241  public:
1242  explicit
1243  mem_fun_ref_t(_Ret (_Tp::*__pf)())
1244  : _M_f(__pf) { }
1245 
1246  _Ret
1247  operator()(_Tp& __r) const
1248  { return (__r.*_M_f)(); }
1249 
1250  private:
1251  _Ret (_Tp::*_M_f)();
1252  };
1253 
1254  /// One of the @link memory_adaptors adaptors for member
1255  /// pointers@endlink.
1256  template<typename _Ret, typename _Tp>
1257  class const_mem_fun_ref_t : public unary_function<_Tp, _Ret>
1258  {
1259  public:
1260  explicit
1261  const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const)
1262  : _M_f(__pf) { }
1263 
1264  _Ret
1265  operator()(const _Tp& __r) const
1266  { return (__r.*_M_f)(); }
1267 
1268  private:
1269  _Ret (_Tp::*_M_f)() const;
1270  };
1271 
1272  /// One of the @link memory_adaptors adaptors for member
1273  /// pointers@endlink.
1274  template<typename _Ret, typename _Tp, typename _Arg>
1275  class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret>
1276  {
1277  public:
1278  explicit
1279  mem_fun1_t(_Ret (_Tp::*__pf)(_Arg))
1280  : _M_f(__pf) { }
1281 
1282  _Ret
1283  operator()(_Tp* __p, _Arg __x) const
1284  { return (__p->*_M_f)(__x); }
1285 
1286  private:
1287  _Ret (_Tp::*_M_f)(_Arg);
1288  };
1289 
1290  /// One of the @link memory_adaptors adaptors for member
1291  /// pointers@endlink.
1292  template<typename _Ret, typename _Tp, typename _Arg>
1293  class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret>
1294  {
1295  public:
1296  explicit
1297  const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const)
1298  : _M_f(__pf) { }
1299 
1300  _Ret
1301  operator()(const _Tp* __p, _Arg __x) const
1302  { return (__p->*_M_f)(__x); }
1303 
1304  private:
1305  _Ret (_Tp::*_M_f)(_Arg) const;
1306  };
1307 
1308  /// One of the @link memory_adaptors adaptors for member
1309  /// pointers@endlink.
1310  template<typename _Ret, typename _Tp, typename _Arg>
1311  class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
1312  {
1313  public:
1314  explicit
1315  mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg))
1316  : _M_f(__pf) { }
1317 
1318  _Ret
1319  operator()(_Tp& __r, _Arg __x) const
1320  { return (__r.*_M_f)(__x); }
1321 
1322  private:
1323  _Ret (_Tp::*_M_f)(_Arg);
1324  };
1325 
1326  /// One of the @link memory_adaptors adaptors for member
1327  /// pointers@endlink.
1328  template<typename _Ret, typename _Tp, typename _Arg>
1329  class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
1330  {
1331  public:
1332  explicit
1333  const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const)
1334  : _M_f(__pf) { }
1335 
1336  _Ret
1337  operator()(const _Tp& __r, _Arg __x) const
1338  { return (__r.*_M_f)(__x); }
1339 
1340  private:
1341  _Ret (_Tp::*_M_f)(_Arg) const;
1342  };
1343 
1344  // Mem_fun adaptor helper functions. There are only two:
1345  // mem_fun and mem_fun_ref.
1346  template<typename _Ret, typename _Tp>
1347  inline mem_fun_t<_Ret, _Tp>
1348  mem_fun(_Ret (_Tp::*__f)())
1349  { return mem_fun_t<_Ret, _Tp>(__f); }
1350 
1351  template<typename _Ret, typename _Tp>
1352  inline const_mem_fun_t<_Ret, _Tp>
1353  mem_fun(_Ret (_Tp::*__f)() const)
1354  { return const_mem_fun_t<_Ret, _Tp>(__f); }
1355 
1356  template<typename _Ret, typename _Tp>
1357  inline mem_fun_ref_t<_Ret, _Tp>
1358  mem_fun_ref(_Ret (_Tp::*__f)())
1359  { return mem_fun_ref_t<_Ret, _Tp>(__f); }
1360 
1361  template<typename _Ret, typename _Tp>
1362  inline const_mem_fun_ref_t<_Ret, _Tp>
1363  mem_fun_ref(_Ret (_Tp::*__f)() const)
1364  { return const_mem_fun_ref_t<_Ret, _Tp>(__f); }
1365 
1366  template<typename _Ret, typename _Tp, typename _Arg>
1367  inline mem_fun1_t<_Ret, _Tp, _Arg>
1368  mem_fun(_Ret (_Tp::*__f)(_Arg))
1369  { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
1370 
1371  template<typename _Ret, typename _Tp, typename _Arg>
1372  inline const_mem_fun1_t<_Ret, _Tp, _Arg>
1373  mem_fun(_Ret (_Tp::*__f)(_Arg) const)
1374  { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
1375 
1376  template<typename _Ret, typename _Tp, typename _Arg>
1377  inline mem_fun1_ref_t<_Ret, _Tp, _Arg>
1378  mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
1379  { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
1380 
1381  template<typename _Ret, typename _Tp, typename _Arg>
1382  inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
1383  mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
1384  { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
1385 
1386  /** @} */
1387 
1388 #if __cplusplus >= 201402L
1389  template<typename _Func, typename _SfinaeType, typename = __void_t<>>
1390  struct __has_is_transparent
1391  { };
1392 
1393  template<typename _Func, typename _SfinaeType>
1394  struct __has_is_transparent<_Func, _SfinaeType,
1395  __void_t<typename _Func::is_transparent>>
1396  { typedef void type; };
1397 
1398  template<typename _Func, typename _SfinaeType>
1399  using __has_is_transparent_t
1400  = typename __has_is_transparent<_Func, _SfinaeType>::type;
1401 #endif
1402 
1403 _GLIBCXX_END_NAMESPACE_VERSION
1404 } // namespace
1405 
1406 #if (__cplusplus < 201103L) || _GLIBCXX_USE_DEPRECATED
1407 # include <backward/binders.h>
1408 #endif
1409 
1410 #endif /* _STL_FUNCTION_H */
auto declval() noexcept -> decltype(__declval< _Tp >(0))
Definition: type_traits:2364
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.
integral_constant
Definition: type_traits:66
is_convertible
Definition: type_traits:1459
_Arg argument_type
argument_type is the type of the argument
Definition: stl_function.h:108
_Result result_type
result_type is the return type
Definition: stl_function.h:111
_Result result_type
result_type is the return type
Definition: stl_function.h:127
_Arg2 second_argument_type
second_argument_type is the type of the second argument
Definition: stl_function.h:124
_Arg1 first_argument_type
first_argument_type is the type of the first argument
Definition: stl_function.h:121
One of the math functors.
Definition: stl_function.h:168
One of the math functors.
Definition: stl_function.h:178
One of the math functors.
Definition: stl_function.h:188
One of the math functors.
Definition: stl_function.h:198
One of the math functors.
Definition: stl_function.h:208
One of the math functors.
Definition: stl_function.h:218
One of the comparison functors.
Definition: stl_function.h:352
One of the comparison functors.
Definition: stl_function.h:362
One of the comparison functors.
Definition: stl_function.h:372
One of the comparison functors.
Definition: stl_function.h:382
One of the comparison functors.
Definition: stl_function.h:392
One of the comparison functors.
Definition: stl_function.h:402
One of the Boolean operations functors.
Definition: stl_function.h:787
One of the Boolean operations functors.
Definition: stl_function.h:797
One of the Boolean operations functors.
Definition: stl_function.h:807
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.