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