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