1// Functor implementations -*- C++ -*- 
2 
3// Copyright (C) 2001-2019 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 @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> 
105 struct unary_function 
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> 
118 struct binary_function 
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 { 
545 return greater<const volatile void*>{}( 
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>, 
572 is_convertible<_Tp, const volatile void*>, 
573 is_convertible<_Up, const volatile void*>>; 
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 { 
607 return less<const volatile void*>{}( 
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>, 
634 is_convertible<_Tp, const volatile void*>, 
635 is_convertible<_Up, const volatile void*>>; 
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 { 
669 return greater_equal<const volatile void*>{}( 
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>, 
696 is_convertible<_Tp, const volatile void*>, 
697 is_convertible<_Up, const volatile void*>>; 
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 { 
731 return less_equal<const volatile void*>{}( 
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>, 
758 is_convertible<_Tp, const volatile void*>, 
759 is_convertible<_Up, const volatile void*>>; 
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> 
1003 class unary_negate 
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 
1023 inline unary_negate<_Predicate> 
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> 
1029 class binary_negate 
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 
1051 inline binary_negate<_Predicate> 
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: 
1086 pointer_to_unary_function() { } 
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> 
1099 inline pointer_to_unary_function<_Arg, _Result> 
1100 ptr_fun(_Result (*__x)(_Arg)) 
1101 { return pointer_to_unary_function<_Arg, _Result>(__x); } 
1102 
1103 /// One of the @link pointer_adaptors adaptors for function pointers@endlink. 
1104 template<typename _Arg1, typename _Arg2, typename _Result> 
1105 class pointer_to_binary_function 
1106 : public binary_function<_Arg1, _Arg2, _Result> 
1107 { 
1108 protected: 
1109 _Result (*_M_ptr)(_Arg1, _Arg2); 
1110 
1111 public: 
1112 pointer_to_binary_function() { } 
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> 
1125 inline pointer_to_binary_function<_Arg1, _Arg2, _Result> 
1126 ptr_fun(_Result (*__x)(_Arg1, _Arg2)) 
1127 { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); } 
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_GLIBCXX_END_NAMESPACE_VERSION 
1389} // namespace 
1390 
1391#if (__cplusplus < 201103L) || _GLIBCXX_USE_DEPRECATED 
1392# include <backward/binders.h> 
1393#endif 
1394 
1395#endif /* _STL_FUNCTION_H */ 
1396