Line data Source code
1 : // Functor implementations -*- C++ -*-
2 :
3 : // Copyright (C) 2001-2021 Free Software Foundation, Inc.
4 : //
5 : // This file is part of the GNU ISO C++ Library. This library is free
6 : // software; you can redistribute it and/or modify it under the
7 : // terms of the GNU General Public License as published by the
8 : // Free Software Foundation; either version 3, or (at your option)
9 : // any later version.
10 :
11 : // This library is distributed in the hope that it will be useful,
12 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : // GNU General Public License for more details.
15 :
16 : // Under Section 7 of GPL version 3, you are granted additional
17 : // permissions described in the GCC Runtime Library Exception, version
18 : // 3.1, as published by the Free Software Foundation.
19 :
20 : // You should have received a copy of the GNU General Public License and
21 : // a copy of the GCC Runtime Library Exception along with this program;
22 : // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 : // <http://www.gnu.org/licenses/>.
24 :
25 : /*
26 : *
27 : * Copyright (c) 1994
28 : * Hewlett-Packard Company
29 : *
30 : * Permission to use, copy, modify, distribute and sell this software
31 : * and its documentation for any purpose is hereby granted without fee,
32 : * provided that the above copyright notice appear in all copies and
33 : * that both that copyright notice and this permission notice appear
34 : * in supporting documentation. Hewlett-Packard Company makes no
35 : * representations about the suitability of this software for any
36 : * purpose. It is provided "as is" without express or implied warranty.
37 : *
38 : *
39 : * Copyright (c) 1996-1998
40 : * Silicon Graphics Computer Systems, Inc.
41 : *
42 : * Permission to use, copy, modify, distribute and sell this software
43 : * and its documentation for any purpose is hereby granted without fee,
44 : * provided that the above copyright notice appear in all copies and
45 : * that both that copyright notice and this permission notice appear
46 : * in supporting documentation. Silicon Graphics makes no
47 : * representations about the suitability of this software for any
48 : * purpose. It is provided "as is" without express or implied warranty.
49 : */
50 :
51 : /** @file bits/stl_function.h
52 : * This is an internal header file, included by other library headers.
53 : * Do not attempt to use it directly. @headername{functional}
54 : */
55 :
56 : #ifndef _STL_FUNCTION_H
57 : #define _STL_FUNCTION_H 1
58 :
59 : #if __cplusplus > 201103L
60 : #include <bits/move.h>
61 : #endif
62 :
63 : namespace std _GLIBCXX_VISIBILITY(default)
64 : {
65 : _GLIBCXX_BEGIN_NAMESPACE_VERSION
66 :
67 : // 20.3.1 base classes
68 : /** @defgroup functors Function Objects
69 : * @ingroup utilities
70 : *
71 : * Function objects, or _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 588 : operator()(const _Tp& __x, const _Tp& __y) const
226 588 : { 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 314 : operator()(const _Tp& __x, const _Tp& __y) const
370 314 : { 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 5359320 : operator()(const _Tp& __x, const _Tp& __y) const
400 5359320 : { 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 84890 : 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 84890 : 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 170499 : 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 340985 : return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
601 170486 : __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 170498 : _S_cmp(_Tp&& __t, _Up&& __u, false_type)
615 170498 : { 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 9062 : operator()(_Tp& __x) const
1155 9062 : { return __x; }
1156 :
1157 : const _Tp&
1158 472153 : operator()(const _Tp& __x) const
1159 472153 : { 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 62837 : operator()(_Pair& __x) const
1171 62837 : { return __x.first; }
1172 :
1173 : const typename _Pair::first_type&
1174 5556284 : operator()(const _Pair& __x) const
1175 5556284 : { 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 */
|
