Line data Source code
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 :
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>
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 0 : operator()(const _Tp& __x, const _Tp& __y) const
172 0 : { 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 0 : operator()(const _Tp& __x, const _Tp& __y) const
356 0 : { 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 884659871 : operator()(const _Tp& __x, const _Tp& __y) const
386 828933761 : { 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 0 : 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 0 : 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 720116416 : 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 450041832 : 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 0 : 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 0 : 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 0 : operator()(const _Tp& __x, const _Tp& __y) const
791 0 : { 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 0 : operator()(const _Tp& __x, const _Tp& __y) const
801 0 : { 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 0 : pointer_to_unary_function(_Result (*__x)(_Arg))
1090 : : _M_ptr(__x) { }
1091 :
1092 : _Result
1093 0 : operator()(_Arg __x) const
1094 0 : { 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 0 : ptr_fun(_Result (*__x)(_Arg))
1101 0 : { 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 0 : pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
1116 : : _M_ptr(__x) { }
1117 :
1118 : _Result
1119 0 : operator()(_Arg1 __x, _Arg2 __y) const
1120 0 : { 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 0 : ptr_fun(_Result (*__x)(_Arg1, _Arg2))
1127 0 : { 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 2776845 : operator()(_Tp& __x) const
1136 : { return __x; }
1137 :
1138 : const _Tp&
1139 1197649932 : 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 0 : operator()(_Pair& __x) const
1152 20950 : { return __x.first; }
1153 :
1154 : const typename _Pair::first_type&
1155 4351199837 : operator()(const _Pair& __x) const
1156 6389588213 : { 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 */
|
