Where Online Learning is simpler!
The C and C++ Include Header Files
/usr/include/c++/13/bits/stl_function.h
$ cat -n /usr/include/c++/13/bits/stl_function.h 1 // Functor implementations -*- C++ -*- 2 3 // Copyright (C) 2001-2023 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 } _GLIBCXX11_DEPRECATED; 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 } _GLIBCXX11_DEPRECATED; 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 // Ignore warnings about unary_function and binary_function. 179 #pragma GCC diagnostic push 180 #pragma GCC diagnostic ignored "-Wdeprecated-declarations" 181 182 /// One of the @link arithmetic_functors math functors@endlink. 183 template<typename _Tp> 184 struct plus : public binary_function<_Tp, _Tp, _Tp> 185 { 186 /// Returns the sum 187 _GLIBCXX14_CONSTEXPR 188 _Tp 189 operator()(const _Tp& __x, const _Tp& __y) const 190 { return __x + __y; } 191 }; 192 193 /// One of the @link arithmetic_functors math functors@endlink. 194 template<typename _Tp> 195 struct minus : public binary_function<_Tp, _Tp, _Tp> 196 { 197 _GLIBCXX14_CONSTEXPR 198 _Tp 199 operator()(const _Tp& __x, const _Tp& __y) const 200 { return __x - __y; } 201 }; 202 203 /// One of the @link arithmetic_functors math functors@endlink. 204 template<typename _Tp> 205 struct multiplies : public binary_function<_Tp, _Tp, _Tp> 206 { 207 _GLIBCXX14_CONSTEXPR 208 _Tp 209 operator()(const _Tp& __x, const _Tp& __y) const 210 { return __x * __y; } 211 }; 212 213 /// One of the @link arithmetic_functors math functors@endlink. 214 template<typename _Tp> 215 struct divides : public binary_function<_Tp, _Tp, _Tp> 216 { 217 _GLIBCXX14_CONSTEXPR 218 _Tp 219 operator()(const _Tp& __x, const _Tp& __y) const 220 { return __x / __y; } 221 }; 222 223 /// One of the @link arithmetic_functors math functors@endlink. 224 template<typename _Tp> 225 struct modulus : public binary_function<_Tp, _Tp, _Tp> 226 { 227 _GLIBCXX14_CONSTEXPR 228 _Tp 229 operator()(const _Tp& __x, const _Tp& __y) const 230 { return __x % __y; } 231 }; 232 233 /// One of the @link arithmetic_functors math functors@endlink. 234 template<typename _Tp> 235 struct negate : public unary_function<_Tp, _Tp> 236 { 237 _GLIBCXX14_CONSTEXPR 238 _Tp 239 operator()(const _Tp& __x) const 240 { return -__x; } 241 }; 242 #pragma GCC diagnostic pop 243 244 #if __cplusplus > 201103L 245 246 #define __cpp_lib_transparent_operators 201510L 247 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 __cplusplus > 201103L 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 #if __cplusplus >= 201402L 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 return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), 532 __ptr_cmp<_Tp, _Up>{}); 533 } 534 535 template<typename _Tp, typename _Up> 536 constexpr bool 537 operator()(_Tp* __t, _Up* __u) const noexcept 538 { return greater<common_type_t<_Tp*, _Up*>>{}(__t, __u); } 539 540 typedef __is_transparent is_transparent; 541 542 private: 543 template <typename _Tp, typename _Up> 544 static constexpr decltype(auto) 545 _S_cmp(_Tp&& __t, _Up&& __u, false_type) 546 { return std::forward<_Tp>(__t) > std::forward<_Up>(__u); } 547 548 template <typename _Tp, typename _Up> 549 static constexpr bool 550 _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept 551 { 552 return greater<const volatile void*>{}( 553 static_cast<const volatile void*>(std::forward<_Tp>(__t)), 554 static_cast<const volatile void*>(std::forward<_Up>(__u))); 555 } 556 557 // True if there is no viable operator> member function. 558 template<typename _Tp, typename _Up, typename = void> 559 struct __not_overloaded2 : true_type { }; 560 561 // False if we can call T.operator>(U) 562 template<typename _Tp, typename _Up> 563 struct __not_overloaded2<_Tp, _Up, __void_t< 564 decltype(std::declval<_Tp>().operator>(std::declval<_Up>()))>> 565 : false_type { }; 566 567 // True if there is no overloaded operator> for these operands. 568 template<typename _Tp, typename _Up, typename = void> 569 struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; 570 571 // False if we can call operator>(T,U) 572 template<typename _Tp, typename _Up> 573 struct __not_overloaded<_Tp, _Up, __void_t< 574 decltype(operator>(std::declval<_Tp>(), std::declval<_Up>()))>> 575 : false_type { }; 576 577 template<typename _Tp, typename _Up> 578 using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, 579 is_convertible<_Tp, const volatile void*>, 580 is_convertible<_Up, const volatile void*>>; 581 }; 582 583 /// One of the @link comparison_functors comparison functors@endlink. 584 template<> 585 struct less<void> 586 { 587 template <typename _Tp, typename _Up> 588 constexpr auto 589 operator()(_Tp&& __t, _Up&& __u) const 590 noexcept(noexcept(std::forward<_Tp>(__t) < std::forward<_Up>(__u))) 591 -> decltype(std::forward<_Tp>(__t) < std::forward<_Up>(__u)) 592 { 593 return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), 594 __ptr_cmp<_Tp, _Up>{}); 595 } 596 597 template<typename _Tp, typename _Up> 598 constexpr bool 599 operator()(_Tp* __t, _Up* __u) const noexcept 600 { return less<common_type_t<_Tp*, _Up*>>{}(__t, __u); } 601 602 typedef __is_transparent is_transparent; 603 604 private: 605 template <typename _Tp, typename _Up> 606 static constexpr decltype(auto) 607 _S_cmp(_Tp&& __t, _Up&& __u, false_type) 608 { return std::forward<_Tp>(__t) < std::forward<_Up>(__u); } 609 610 template <typename _Tp, typename _Up> 611 static constexpr bool 612 _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept 613 { 614 return less<const volatile void*>{}( 615 static_cast<const volatile void*>(std::forward<_Tp>(__t)), 616 static_cast<const volatile void*>(std::forward<_Up>(__u))); 617 } 618 619 // True if there is no viable operator< member function. 620 template<typename _Tp, typename _Up, typename = void> 621 struct __not_overloaded2 : true_type { }; 622 623 // False if we can call T.operator<(U) 624 template<typename _Tp, typename _Up> 625 struct __not_overloaded2<_Tp, _Up, __void_t< 626 decltype(std::declval<_Tp>().operator<(std::declval<_Up>()))>> 627 : false_type { }; 628 629 // True if there is no overloaded operator< for these operands. 630 template<typename _Tp, typename _Up, typename = void> 631 struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; 632 633 // False if we can call operator<(T,U) 634 template<typename _Tp, typename _Up> 635 struct __not_overloaded<_Tp, _Up, __void_t< 636 decltype(operator<(std::declval<_Tp>(), std::declval<_Up>()))>> 637 : false_type { }; 638 639 template<typename _Tp, typename _Up> 640 using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, 641 is_convertible<_Tp, const volatile void*>, 642 is_convertible<_Up, const volatile void*>>; 643 }; 644 645 /// One of the @link comparison_functors comparison functors@endlink. 646 template<> 647 struct greater_equal<void> 648 { 649 template <typename _Tp, typename _Up> 650 constexpr auto 651 operator()(_Tp&& __t, _Up&& __u) const 652 noexcept(noexcept(std::forward<_Tp>(__t) >= std::forward<_Up>(__u))) 653 -> decltype(std::forward<_Tp>(__t) >= std::forward<_Up>(__u)) 654 { 655 return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), 656 __ptr_cmp<_Tp, _Up>{}); 657 } 658 659 template<typename _Tp, typename _Up> 660 constexpr bool 661 operator()(_Tp* __t, _Up* __u) const noexcept 662 { return greater_equal<common_type_t<_Tp*, _Up*>>{}(__t, __u); } 663 664 typedef __is_transparent is_transparent; 665 666 private: 667 template <typename _Tp, typename _Up> 668 static constexpr decltype(auto) 669 _S_cmp(_Tp&& __t, _Up&& __u, false_type) 670 { return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); } 671 672 template <typename _Tp, typename _Up> 673 static constexpr bool 674 _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept 675 { 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 } 680 681 // True if there is no viable operator>= member function. 682 template<typename _Tp, typename _Up, typename = void> 683 struct __not_overloaded2 : true_type { }; 684 685 // False if we can call T.operator>=(U) 686 template<typename _Tp, typename _Up> 687 struct __not_overloaded2<_Tp, _Up, __void_t< 688 decltype(std::declval<_Tp>().operator>=(std::declval<_Up>()))>> 689 : false_type { }; 690 691 // True if there is no overloaded operator>= for these operands. 692 template<typename _Tp, typename _Up, typename = void> 693 struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; 694 695 // False if we can call operator>=(T,U) 696 template<typename _Tp, typename _Up> 697 struct __not_overloaded<_Tp, _Up, __void_t< 698 decltype(operator>=(std::declval<_Tp>(), std::declval<_Up>()))>> 699 : false_type { }; 700 701 template<typename _Tp, typename _Up> 702 using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, 703 is_convertible<_Tp, const volatile void*>, 704 is_convertible<_Up, const volatile void*>>; 705 }; 706 707 /// One of the @link comparison_functors comparison functors@endlink. 708 template<> 709 struct less_equal<void> 710 { 711 template <typename _Tp, typename _Up> 712 constexpr auto 713 operator()(_Tp&& __t, _Up&& __u) const 714 noexcept(noexcept(std::forward<_Tp>(__t) <= std::forward<_Up>(__u))) 715 -> decltype(std::forward<_Tp>(__t) <= std::forward<_Up>(__u)) 716 { 717 return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), 718 __ptr_cmp<_Tp, _Up>{}); 719 } 720 721 template<typename _Tp, typename _Up> 722 constexpr bool 723 operator()(_Tp* __t, _Up* __u) const noexcept 724 { return less_equal<common_type_t<_Tp*, _Up*>>{}(__t, __u); } 725 726 typedef __is_transparent is_transparent; 727 728 private: 729 template <typename _Tp, typename _Up> 730 static constexpr decltype(auto) 731 _S_cmp(_Tp&& __t, _Up&& __u, false_type) 732 { return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); } 733 734 template <typename _Tp, typename _Up> 735 static constexpr bool 736 _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept 737 { 738 return less_equal<const volatile void*>{}( 739 static_cast<const volatile void*>(std::forward<_Tp>(__t)), 740 static_cast<const volatile void*>(std::forward<_Up>(__u))); 741 } 742 743 // True if there is no viable operator<= member function. 744 template<typename _Tp, typename _Up, typename = void> 745 struct __not_overloaded2 : true_type { }; 746 747 // False if we can call T.operator<=(U) 748 template<typename _Tp, typename _Up> 749 struct __not_overloaded2<_Tp, _Up, __void_t< 750 decltype(std::declval<_Tp>().operator<=(std::declval<_Up>()))>> 751 : false_type { }; 752 753 // True if there is no overloaded operator<= for these operands. 754 template<typename _Tp, typename _Up, typename = void> 755 struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; 756 757 // False if we can call operator<=(T,U) 758 template<typename _Tp, typename _Up> 759 struct __not_overloaded<_Tp, _Up, __void_t< 760 decltype(operator<=(std::declval<_Tp>(), std::declval<_Up>()))>> 761 : false_type { }; 762 763 template<typename _Tp, typename _Up> 764 using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, 765 is_convertible<_Tp, const volatile void*>, 766 is_convertible<_Up, const volatile void*>>; 767 }; 768 #endif // C++14 769 /** @} */ 770 771 // 20.3.4 logical operations 772 /** @defgroup logical_functors Boolean Operations Classes 773 * @ingroup functors 774 * 775 * The library provides function objects for the logical operations: 776 * `&&`, `||`, and `!`. 777 * 778 * @{ 779 */ 780 #if __cplusplus > 201103L 781 template<typename _Tp = void> 782 struct logical_and; 783 784 template<typename _Tp = void> 785 struct logical_or; 786 787 template<typename _Tp = void> 788 struct logical_not; 789 #endif 790 791 #pragma GCC diagnostic push 792 #pragma GCC diagnostic ignored "-Wdeprecated-declarations" 793 794 /// One of the @link logical_functors Boolean operations functors@endlink. 795 template<typename _Tp> 796 struct logical_and : public binary_function<_Tp, _Tp, bool> 797 { 798 _GLIBCXX14_CONSTEXPR 799 bool 800 operator()(const _Tp& __x, const _Tp& __y) const 801 { return __x && __y; } 802 }; 803 804 /// One of the @link logical_functors Boolean operations functors@endlink. 805 template<typename _Tp> 806 struct logical_or : public binary_function<_Tp, _Tp, bool> 807 { 808 _GLIBCXX14_CONSTEXPR 809 bool 810 operator()(const _Tp& __x, const _Tp& __y) const 811 { return __x || __y; } 812 }; 813 814 /// One of the @link logical_functors Boolean operations functors@endlink. 815 template<typename _Tp> 816 struct logical_not : public unary_function<_Tp, bool> 817 { 818 _GLIBCXX14_CONSTEXPR 819 bool 820 operator()(const _Tp& __x) const 821 { return !__x; } 822 }; 823 #pragma GCC diagnostic pop 824 825 #if __cplusplus > 201103L 826 /// One of the @link logical_functors Boolean operations functors@endlink. 827 template<> 828 struct logical_and<void> 829 { 830 template <typename _Tp, typename _Up> 831 _GLIBCXX14_CONSTEXPR 832 auto 833 operator()(_Tp&& __t, _Up&& __u) const 834 noexcept(noexcept(std::forward<_Tp>(__t) && std::forward<_Up>(__u))) 835 -> decltype(std::forward<_Tp>(__t) && std::forward<_Up>(__u)) 836 { return std::forward<_Tp>(__t) && std::forward<_Up>(__u); } 837 838 typedef __is_transparent is_transparent; 839 }; 840 841 /// One of the @link logical_functors Boolean operations functors@endlink. 842 template<> 843 struct logical_or<void> 844 { 845 template <typename _Tp, typename _Up> 846 _GLIBCXX14_CONSTEXPR 847 auto 848 operator()(_Tp&& __t, _Up&& __u) const 849 noexcept(noexcept(std::forward<_Tp>(__t) || std::forward<_Up>(__u))) 850 -> decltype(std::forward<_Tp>(__t) || std::forward<_Up>(__u)) 851 { return std::forward<_Tp>(__t) || std::forward<_Up>(__u); } 852 853 typedef __is_transparent is_transparent; 854 }; 855 856 /// One of the @link logical_functors Boolean operations functors@endlink. 857 template<> 858 struct logical_not<void> 859 { 860 template <typename _Tp> 861 _GLIBCXX14_CONSTEXPR 862 auto 863 operator()(_Tp&& __t) const 864 noexcept(noexcept(!std::forward<_Tp>(__t))) 865 -> decltype(!std::forward<_Tp>(__t)) 866 { return !std::forward<_Tp>(__t); } 867 868 typedef __is_transparent is_transparent; 869 }; 870 #endif 871 /** @} */ 872 873 #if __cplusplus > 201103L 874 template<typename _Tp = void> 875 struct bit_and; 876 877 template<typename _Tp = void> 878 struct bit_or; 879 880 template<typename _Tp = void> 881 struct bit_xor; 882 883 template<typename _Tp = void> 884 struct bit_not; 885 #endif 886 887 #pragma GCC diagnostic push 888 #pragma GCC diagnostic ignored "-Wdeprecated-declarations" 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 #pragma GCC diagnostic pop 928 929 #if __cplusplus > 201103L 930 template <> 931 struct bit_and<void> 932 { 933 template <typename _Tp, typename _Up> 934 _GLIBCXX14_CONSTEXPR 935 auto 936 operator()(_Tp&& __t, _Up&& __u) const 937 noexcept(noexcept(std::forward<_Tp>(__t) & std::forward<_Up>(__u))) 938 -> decltype(std::forward<_Tp>(__t) & std::forward<_Up>(__u)) 939 { return std::forward<_Tp>(__t) & std::forward<_Up>(__u); } 940 941 typedef __is_transparent is_transparent; 942 }; 943 944 template <> 945 struct bit_or<void> 946 { 947 template <typename _Tp, typename _Up> 948 _GLIBCXX14_CONSTEXPR 949 auto 950 operator()(_Tp&& __t, _Up&& __u) const 951 noexcept(noexcept(std::forward<_Tp>(__t) | std::forward<_Up>(__u))) 952 -> decltype(std::forward<_Tp>(__t) | std::forward<_Up>(__u)) 953 { return std::forward<_Tp>(__t) | std::forward<_Up>(__u); } 954 955 typedef __is_transparent is_transparent; 956 }; 957 958 template <> 959 struct bit_xor<void> 960 { 961 template <typename _Tp, typename _Up> 962 _GLIBCXX14_CONSTEXPR 963 auto 964 operator()(_Tp&& __t, _Up&& __u) const 965 noexcept(noexcept(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u))) 966 -> decltype(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u)) 967 { return std::forward<_Tp>(__t) ^ std::forward<_Up>(__u); } 968 969 typedef __is_transparent is_transparent; 970 }; 971 972 template <> 973 struct bit_not<void> 974 { 975 template <typename _Tp> 976 _GLIBCXX14_CONSTEXPR 977 auto 978 operator()(_Tp&& __t) const 979 noexcept(noexcept(~std::forward<_Tp>(__t))) 980 -> decltype(~std::forward<_Tp>(__t)) 981 { return ~std::forward<_Tp>(__t); } 982 983 typedef __is_transparent is_transparent; 984 }; 985 #endif // C++14 986 987 #pragma GCC diagnostic push 988 #pragma GCC diagnostic ignored "-Wdeprecated-declarations" 989 990 // 20.3.5 negators 991 /** @defgroup negators Negators 992 * @ingroup functors 993 * 994 * The function templates `not1` and `not2` are function object adaptors, 995 * which each take a predicate functor and wrap it in an instance of 996 * `unary_negate` or `binary_negate`, respectively. Those classes are 997 * functors whose `operator()` evaluates the wrapped predicate function 998 * and then returns the negation of the result. 999 * 1000 * For example, given a vector of integers and a trivial predicate, 1001 * \code 1002 * struct IntGreaterThanThree 1003 * : public std::unary_function<int, bool> 1004 * { 1005 * bool operator() (int x) const { return x > 3; } 1006 * }; 1007 * 1008 * std::find_if (v.begin(), v.end(), not1(IntGreaterThanThree())); 1009 * \endcode 1010 * The call to `find_if` will locate the first index (i) of `v` for which 1011 * `!(v[i] > 3)` is true. 1012 * 1013 * The not1/unary_negate combination works on predicates taking a single 1014 * argument. The not2/binary_negate combination works on predicates taking 1015 * two arguments. 1016 * 1017 * @deprecated Deprecated in C++17, no longer in the standard since C++20. 1018 * Use `not_fn` instead. 1019 * 1020 * @{ 1021 */ 1022 /// One of the @link negators negation functors@endlink. 1023 template<typename _Predicate> 1024 class _GLIBCXX17_DEPRECATED unary_negate 1025 : public unary_function<typename _Predicate::argument_type, bool> 1026 { 1027 protected: 1028 _Predicate _M_pred; 1029 1030 public: 1031 _GLIBCXX14_CONSTEXPR 1032 explicit 1033 unary_negate(const _Predicate& __x) : _M_pred(__x) { } 1034 1035 _GLIBCXX14_CONSTEXPR 1036 bool 1037 operator()(const typename _Predicate::argument_type& __x) const 1038 { return !_M_pred(__x); } 1039 }; 1040 1041 /// One of the @link negators negation functors@endlink. 1042 template<typename _Predicate> 1043 _GLIBCXX17_DEPRECATED_SUGGEST("std::not_fn") 1044 _GLIBCXX14_CONSTEXPR 1045 inline unary_negate<_Predicate> 1046 not1(const _Predicate& __pred) 1047 { return unary_negate<_Predicate>(__pred); } 1048 1049 /// One of the @link negators negation functors@endlink. 1050 template<typename _Predicate> 1051 class _GLIBCXX17_DEPRECATED binary_negate 1052 : public binary_function<typename _Predicate::first_argument_type, 1053 typename _Predicate::second_argument_type, bool> 1054 { 1055 protected: 1056 _Predicate _M_pred; 1057 1058 public: 1059 _GLIBCXX14_CONSTEXPR 1060 explicit 1061 binary_negate(const _Predicate& __x) : _M_pred(__x) { } 1062 1063 _GLIBCXX14_CONSTEXPR 1064 bool 1065 operator()(const typename _Predicate::first_argument_type& __x, 1066 const typename _Predicate::second_argument_type& __y) const 1067 { return !_M_pred(__x, __y); } 1068 }; 1069 1070 /// One of the @link negators negation functors@endlink. 1071 template<typename _Predicate> 1072 _GLIBCXX17_DEPRECATED_SUGGEST("std::not_fn") 1073 _GLIBCXX14_CONSTEXPR 1074 inline binary_negate<_Predicate> 1075 not2(const _Predicate& __pred) 1076 { return binary_negate<_Predicate>(__pred); } 1077 /** @} */ 1078 1079 // 20.3.7 adaptors pointers functions 1080 /** @defgroup pointer_adaptors Adaptors for pointers to functions 1081 * @ingroup functors 1082 * 1083 * The advantage of function objects over pointers to functions is that 1084 * the objects in the standard library declare nested typedefs describing 1085 * their argument and result types with uniform names (e.g., `result_type` 1086 * from the base classes `unary_function` and `binary_function`). 1087 * Sometimes those typedefs are required, not just optional. 1088 * 1089 * Adaptors are provided to turn pointers to unary (single-argument) and 1090 * binary (double-argument) functions into function objects. The 1091 * long-winded functor `pointer_to_unary_function` is constructed with a 1092 * function pointer `f`, and its `operator()` called with argument `x` 1093 * returns `f(x)`. The functor `pointer_to_binary_function` does the same 1094 * thing, but with a double-argument `f` and `operator()`. 1095 * 1096 * The function `ptr_fun` takes a pointer-to-function `f` and constructs 1097 * an instance of the appropriate functor. 1098 * 1099 * @deprecated Deprecated in C++11, no longer in the standard since C++17. 1100 * 1101 * @{ 1102 */ 1103 /// One of the @link pointer_adaptors adaptors for function pointers@endlink. 1104 template<typename _Arg, typename _Result> 1105 class pointer_to_unary_function : public unary_function<_Arg, _Result> 1106 { 1107 protected: 1108 _Result (*_M_ptr)(_Arg); 1109 1110 public: 1111 pointer_to_unary_function() { } 1112 1113 explicit 1114 pointer_to_unary_function(_Result (*__x)(_Arg)) 1115 : _M_ptr(__x) { } 1116 1117 _Result 1118 operator()(_Arg __x) const 1119 { return _M_ptr(__x); } 1120 } _GLIBCXX11_DEPRECATED; 1121 1122 /// One of the @link pointer_adaptors adaptors for function pointers@endlink. 1123 template<typename _Arg, typename _Result> 1124 _GLIBCXX11_DEPRECATED_SUGGEST("std::function") 1125 inline pointer_to_unary_function<_Arg, _Result> 1126 ptr_fun(_Result (*__x)(_Arg)) 1127 { return pointer_to_unary_function<_Arg, _Result>(__x); } 1128 1129 /// One of the @link pointer_adaptors adaptors for function pointers@endlink. 1130 template<typename _Arg1, typename _Arg2, typename _Result> 1131 class pointer_to_binary_function 1132 : public binary_function<_Arg1, _Arg2, _Result> 1133 { 1134 protected: 1135 _Result (*_M_ptr)(_Arg1, _Arg2); 1136 1137 public: 1138 pointer_to_binary_function() { } 1139 1140 explicit 1141 pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2)) 1142 : _M_ptr(__x) { } 1143 1144 _Result 1145 operator()(_Arg1 __x, _Arg2 __y) const 1146 { return _M_ptr(__x, __y); } 1147 } _GLIBCXX11_DEPRECATED; 1148 1149 /// One of the @link pointer_adaptors adaptors for function pointers@endlink. 1150 template<typename _Arg1, typename _Arg2, typename _Result> 1151 _GLIBCXX11_DEPRECATED_SUGGEST("std::function") 1152 inline pointer_to_binary_function<_Arg1, _Arg2, _Result> 1153 ptr_fun(_Result (*__x)(_Arg1, _Arg2)) 1154 { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); } 1155 /** @} */ 1156 1157 template<typename _Tp> 1158 struct _Identity 1159 : public unary_function<_Tp, _Tp> 1160 { 1161 _Tp& 1162 operator()(_Tp& __x) const 1163 { return __x; } 1164 1165 const _Tp& 1166 operator()(const _Tp& __x) const 1167 { return __x; } 1168 }; 1169 1170 // Partial specialization, avoids confusing errors in e.g. std::set<const T>. 1171 template<typename _Tp> struct _Identity<const _Tp> : _Identity<_Tp> { }; 1172 1173 template<typename _Pair> 1174 struct _Select1st 1175 : public unary_function<_Pair, typename _Pair::first_type> 1176 { 1177 typename _Pair::first_type& 1178 operator()(_Pair& __x) const 1179 { return __x.first; } 1180 1181 const typename _Pair::first_type& 1182 operator()(const _Pair& __x) const 1183 { return __x.first; } 1184 1185 #if __cplusplus >= 201103L 1186 template<typename _Pair2> 1187 typename _Pair2::first_type& 1188 operator()(_Pair2& __x) const 1189 { return __x.first; } 1190 1191 template<typename _Pair2> 1192 const typename _Pair2::first_type& 1193 operator()(const _Pair2& __x) const 1194 { return __x.first; } 1195 #endif 1196 }; 1197 1198 template<typename _Pair> 1199 struct _Select2nd 1200 : public unary_function<_Pair, typename _Pair::second_type> 1201 { 1202 typename _Pair::second_type& 1203 operator()(_Pair& __x) const 1204 { return __x.second; } 1205 1206 const typename _Pair::second_type& 1207 operator()(const _Pair& __x) const 1208 { return __x.second; } 1209 }; 1210 1211 // 20.3.8 adaptors pointers members 1212 /** @defgroup ptrmem_adaptors Adaptors for pointers to members 1213 * @ingroup functors 1214 * 1215 * There are a total of 8 = 2^3 function objects in this family. 1216 * (1) Member functions taking no arguments vs member functions taking 1217 * one argument. 1218 * (2) Call through pointer vs call through reference. 1219 * (3) Const vs non-const member function. 1220 * 1221 * All of this complexity is in the function objects themselves. You can 1222 * ignore it by using the helper function `mem_fun` and `mem_fun_ref`, 1223 * which create whichever type of adaptor is appropriate. 1224 * 1225 * @deprecated Deprecated in C++11, no longer in the standard since C++17. 1226 * Use `mem_fn` instead. 1227 * 1228 * @{ 1229 */ 1230 /// One of the @link ptrmem_adaptors adaptors for member pointers@endlink. 1231 template<typename _Ret, typename _Tp> 1232 class mem_fun_t : public unary_function<_Tp*, _Ret> 1233 { 1234 public: 1235 explicit 1236 mem_fun_t(_Ret (_Tp::*__pf)()) 1237 : _M_f(__pf) { } 1238 1239 _Ret 1240 operator()(_Tp* __p) const 1241 { return (__p->*_M_f)(); } 1242 1243 private: 1244 _Ret (_Tp::*_M_f)(); 1245 } _GLIBCXX11_DEPRECATED; 1246 1247 /// One of the @link ptrmem_adaptors adaptors for member pointers@endlink. 1248 template<typename _Ret, typename _Tp> 1249 class const_mem_fun_t : public unary_function<const _Tp*, _Ret> 1250 { 1251 public: 1252 explicit 1253 const_mem_fun_t(_Ret (_Tp::*__pf)() const) 1254 : _M_f(__pf) { } 1255 1256 _Ret 1257 operator()(const _Tp* __p) const 1258 { return (__p->*_M_f)(); } 1259 1260 private: 1261 _Ret (_Tp::*_M_f)() const; 1262 } _GLIBCXX11_DEPRECATED; 1263 1264 /// One of the @link ptrmem_adaptors adaptors for member pointers@endlink. 1265 template<typename _Ret, typename _Tp> 1266 class mem_fun_ref_t : public unary_function<_Tp, _Ret> 1267 { 1268 public: 1269 explicit 1270 mem_fun_ref_t(_Ret (_Tp::*__pf)()) 1271 : _M_f(__pf) { } 1272 1273 _Ret 1274 operator()(_Tp& __r) const 1275 { return (__r.*_M_f)(); } 1276 1277 private: 1278 _Ret (_Tp::*_M_f)(); 1279 } _GLIBCXX11_DEPRECATED; 1280 1281 /// One of the @link ptrmem_adaptors adaptors for member pointers@endlink. 1282 template<typename _Ret, typename _Tp> 1283 class const_mem_fun_ref_t : public unary_function<_Tp, _Ret> 1284 { 1285 public: 1286 explicit 1287 const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const) 1288 : _M_f(__pf) { } 1289 1290 _Ret 1291 operator()(const _Tp& __r) const 1292 { return (__r.*_M_f)(); } 1293 1294 private: 1295 _Ret (_Tp::*_M_f)() const; 1296 } _GLIBCXX11_DEPRECATED; 1297 1298 /// One of the @link ptrmem_adaptors adaptors for member pointers@endlink. 1299 template<typename _Ret, typename _Tp, typename _Arg> 1300 class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret> 1301 { 1302 public: 1303 explicit 1304 mem_fun1_t(_Ret (_Tp::*__pf)(_Arg)) 1305 : _M_f(__pf) { } 1306 1307 _Ret 1308 operator()(_Tp* __p, _Arg __x) const 1309 { return (__p->*_M_f)(__x); } 1310 1311 private: 1312 _Ret (_Tp::*_M_f)(_Arg); 1313 } _GLIBCXX11_DEPRECATED; 1314 1315 /// One of the @link ptrmem_adaptors adaptors for member pointers@endlink. 1316 template<typename _Ret, typename _Tp, typename _Arg> 1317 class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret> 1318 { 1319 public: 1320 explicit 1321 const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const) 1322 : _M_f(__pf) { } 1323 1324 _Ret 1325 operator()(const _Tp* __p, _Arg __x) const 1326 { return (__p->*_M_f)(__x); } 1327 1328 private: 1329 _Ret (_Tp::*_M_f)(_Arg) const; 1330 } _GLIBCXX11_DEPRECATED; 1331 1332 /// One of the @link ptrmem_adaptors adaptors for member pointers@endlink. 1333 template<typename _Ret, typename _Tp, typename _Arg> 1334 class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> 1335 { 1336 public: 1337 explicit 1338 mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg)) 1339 : _M_f(__pf) { } 1340 1341 _Ret 1342 operator()(_Tp& __r, _Arg __x) const 1343 { return (__r.*_M_f)(__x); } 1344 1345 private: 1346 _Ret (_Tp::*_M_f)(_Arg); 1347 } _GLIBCXX11_DEPRECATED; 1348 1349 /// One of the @link ptrmem_adaptors adaptors for member pointers@endlink. 1350 template<typename _Ret, typename _Tp, typename _Arg> 1351 class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> 1352 { 1353 public: 1354 explicit 1355 const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const) 1356 : _M_f(__pf) { } 1357 1358 _Ret 1359 operator()(const _Tp& __r, _Arg __x) const 1360 { return (__r.*_M_f)(__x); } 1361 1362 private: 1363 _Ret (_Tp::*_M_f)(_Arg) const; 1364 } _GLIBCXX11_DEPRECATED; 1365 1366 // Mem_fun adaptor helper functions. There are only two: 1367 // mem_fun and mem_fun_ref. 1368 template<typename _Ret, typename _Tp> 1369 _GLIBCXX11_DEPRECATED_SUGGEST("std::mem_fn") 1370 inline mem_fun_t<_Ret, _Tp> 1371 mem_fun(_Ret (_Tp::*__f)()) 1372 { return mem_fun_t<_Ret, _Tp>(__f); } 1373 1374 template<typename _Ret, typename _Tp> 1375 _GLIBCXX11_DEPRECATED_SUGGEST("std::mem_fn") 1376 inline const_mem_fun_t<_Ret, _Tp> 1377 mem_fun(_Ret (_Tp::*__f)() const) 1378 { return const_mem_fun_t<_Ret, _Tp>(__f); } 1379 1380 template<typename _Ret, typename _Tp> 1381 _GLIBCXX11_DEPRECATED_SUGGEST("std::mem_fn") 1382 inline mem_fun_ref_t<_Ret, _Tp> 1383 mem_fun_ref(_Ret (_Tp::*__f)()) 1384 { return mem_fun_ref_t<_Ret, _Tp>(__f); } 1385 1386 template<typename _Ret, typename _Tp> 1387 _GLIBCXX11_DEPRECATED_SUGGEST("std::mem_fn") 1388 inline const_mem_fun_ref_t<_Ret, _Tp> 1389 mem_fun_ref(_Ret (_Tp::*__f)() const) 1390 { return const_mem_fun_ref_t<_Ret, _Tp>(__f); } 1391 1392 template<typename _Ret, typename _Tp, typename _Arg> 1393 _GLIBCXX11_DEPRECATED_SUGGEST("std::mem_fn") 1394 inline mem_fun1_t<_Ret, _Tp, _Arg> 1395 mem_fun(_Ret (_Tp::*__f)(_Arg)) 1396 { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); } 1397 1398 template<typename _Ret, typename _Tp, typename _Arg> 1399 _GLIBCXX11_DEPRECATED_SUGGEST("std::mem_fn") 1400 inline const_mem_fun1_t<_Ret, _Tp, _Arg> 1401 mem_fun(_Ret (_Tp::*__f)(_Arg) const) 1402 { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); } 1403 1404 template<typename _Ret, typename _Tp, typename _Arg> 1405 _GLIBCXX11_DEPRECATED_SUGGEST("std::mem_fn") 1406 inline mem_fun1_ref_t<_Ret, _Tp, _Arg> 1407 mem_fun_ref(_Ret (_Tp::*__f)(_Arg)) 1408 { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } 1409 1410 template<typename _Ret, typename _Tp, typename _Arg> 1411 _GLIBCXX11_DEPRECATED_SUGGEST("std::mem_fn") 1412 inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg> 1413 mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const) 1414 { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } 1415 #pragma GCC diagnostic pop 1416 1417 /** @} */ 1418 1419 #if __cplusplus >= 201402L 1420 template<typename _Func, typename _SfinaeType, typename = __void_t<>> 1421 struct __has_is_transparent 1422 { }; 1423 1424 template<typename _Func, typename _SfinaeType> 1425 struct __has_is_transparent<_Func, _SfinaeType, 1426 __void_t<typename _Func::is_transparent>> 1427 { typedef void type; }; 1428 1429 template<typename _Func, typename _SfinaeType> 1430 using __has_is_transparent_t 1431 = typename __has_is_transparent<_Func, _SfinaeType>::type; 1432 #endif 1433 1434 _GLIBCXX_END_NAMESPACE_VERSION 1435 } // namespace 1436 1437 #if (__cplusplus < 201103L) || _GLIBCXX_USE_DEPRECATED 1438 # include <backward/binders.h> 1439 #endif 1440 1441 #endif /* _STL_FUNCTION_H */
Contact us
|
About us
|
Term of use
|
Copyright © 2000-2025 MyWebUniversity.com ™
