1 // Functor implementations -*- C++ -*- 2 3 // Copyright (C) 2001-2015 Free Software Foundation, Inc. 4 // 5 // This file is part of the GNU ISO C++ Library. This library is free 6 // software; you can redistribute it and/or modify it under the 7 // terms of the GNU General Public License as published by the 8 // Free Software Foundation; either version 3, or (at your option) 9 // any later version. 10 11 // This library is distributed in the hope that it will be useful, 12 // but WITHOUT ANY WARRANTY; without even the implied warranty of 13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 // GNU General Public License for more details. 15 16 // Under Section 7 of GPL version 3, you are granted additional 17 // permissions described in the GCC Runtime Library Exception, version 18 // 3.1, as published by the Free Software Foundation. 19 20 // You should have received a copy of the GNU General Public License and 21 // a copy of the GCC Runtime Library Exception along with this program; 22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 23 // <http://www.gnu.org/licenses/>. 24 25 /* 26 * 27 * Copyright (c) 1994 28 * Hewlett-Packard Company 29 * 30 * Permission to use, copy, modify, distribute and sell this software 31 * and its documentation for any purpose is hereby granted without fee, 32 * provided that the above copyright notice appear in all copies and 33 * that both that copyright notice and this permission notice appear 34 * in supporting documentation. Hewlett-Packard Company makes no 35 * representations about the suitability of this software for any 36 * purpose. It is provided "as is" without express or implied warranty. 37 * 38 * 39 * Copyright (c) 1996-1998 40 * Silicon Graphics Computer Systems, Inc. 41 * 42 * Permission to use, copy, modify, distribute and sell this software 43 * and its documentation for any purpose is hereby granted without fee, 44 * provided that the above copyright notice appear in all copies and 45 * that both that copyright notice and this permission notice appear 46 * in supporting documentation. Silicon Graphics makes no 47 * representations about the suitability of this software for any 48 * purpose. It is provided "as is" without express or implied warranty. 49 */ 50 51 /** @file bits/stl_function.h 52 * This is an internal header file, included by other library headers. 53 * Do not attempt to use it directly. @headername{functional} 54 */ 55 56 #ifndef _STL_FUNCTION_H 57 #define _STL_FUNCTION_H 1 58 59 #if __cplusplus > 201103L 60 #include <bits/move.h> 61 #endif 62 63 namespace std _GLIBCXX_VISIBILITY(default) 64 { 65 _GLIBCXX_BEGIN_NAMESPACE_VERSION 66 67 // 20.3.1 base classes 68 /** @defgroup functors Function Objects 69 * @ingroup utilities 70 * 71 * Function objects, or @e functors, are objects with an @c operator() 72 * defined and accessible. They can be passed as arguments to algorithm 73 * templates and used in place of a function pointer. Not only is the 74 * resulting expressiveness of the library increased, but the generated 75 * code can be more efficient than what you might write by hand. When we 76 * refer to @a functors, then, generally we include function pointers in 77 * the description as well. 78 * 79 * Often, functors are only created as temporaries passed to algorithm 80 * calls, rather than being created as named variables. 81 * 82 * Two examples taken from the standard itself follow. To perform a 83 * by-element addition of two vectors @c a and @c b containing @c double, 84 * and put the result in @c a, use 85 * \code 86 * transform (a.begin(), a.end(), b.begin(), a.begin(), plus<double>()); 87 * \endcode 88 * To negate every element in @c a, use 89 * \code 90 * transform(a.begin(), a.end(), a.begin(), negate<double>()); 91 * \endcode 92 * The addition and negation functions will be inlined directly. 93 * 94 * The standard functors are derived from structs named @c unary_function 95 * and @c binary_function. These two classes contain nothing but typedefs, 96 * to aid in generic (template) programming. If you write your own 97 * functors, you might consider doing the same. 98 * 99 * @{ 100 */ 101 /** 102 * This is one of the @link functors functor base classes@endlink. 103 */ 104 template<typename _Arg, typename _Result> 105 struct unary_function 106 { 107 /// @c argument_type is the type of the argument 108 typedef _Arg argument_type; 109 110 /// @c result_type is the return type 111 typedef _Result result_type; 112 }; 113 114 /** 115 * This is one of the @link functors functor base classes@endlink. 116 */ 117 template<typename _Arg1, typename _Arg2, typename _Result> 118 struct binary_function 119 { 120 /// @c first_argument_type is the type of the first argument 121 typedef _Arg1 first_argument_type; 122 123 /// @c second_argument_type is the type of the second argument 124 typedef _Arg2 second_argument_type; 125 126 /// @c result_type is the return type 127 typedef _Result result_type; 128 }; 129 /** @} */ 130 131 // 20.3.2 arithmetic 132 /** @defgroup arithmetic_functors Arithmetic Classes 133 * @ingroup functors 134 * 135 * Because basic math often needs to be done during an algorithm, 136 * the library provides functors for those operations. See the 137 * documentation for @link functors the base classes@endlink 138 * for examples of their use. 139 * 140 * @{ 141 */ 142 143 #if __cplusplus > 201103L 144 struct __is_transparent; // undefined 145 146 template<typename _Tp = void> 147 struct plus; 148 149 template<typename _Tp = void> 150 struct minus; 151 152 template<typename _Tp = void> 153 struct multiplies; 154 155 template<typename _Tp = void> 156 struct divides; 157 158 template<typename _Tp = void> 159 struct modulus; 160 161 template<typename _Tp = void> 162 struct negate; 163 #endif 164 165 /// One of the @link arithmetic_functors math functors@endlink. 166 template<typename _Tp> 167 struct plus : public binary_function<_Tp, _Tp, _Tp> 168 { 169 _GLIBCXX14_CONSTEXPR 170 _Tp 171 operator()(const _Tp& __x, const _Tp& __y) const 172 { return __x + __y; } 173 }; 174 175 /// One of the @link arithmetic_functors math functors@endlink. 176 template<typename _Tp> 177 struct minus : public binary_function<_Tp, _Tp, _Tp> 178 { 179 _GLIBCXX14_CONSTEXPR 180 _Tp 181 operator()(const _Tp& __x, const _Tp& __y) const 182 { return __x - __y; } 183 }; 184 185 /// One of the @link arithmetic_functors math functors@endlink. 186 template<typename _Tp> 187 struct multiplies : public binary_function<_Tp, _Tp, _Tp> 188 { 189 _GLIBCXX14_CONSTEXPR 190 _Tp 191 operator()(const _Tp& __x, const _Tp& __y) const 192 { return __x * __y; } 193 }; 194 195 /// One of the @link arithmetic_functors math functors@endlink. 196 template<typename _Tp> 197 struct divides : public binary_function<_Tp, _Tp, _Tp> 198 { 199 _GLIBCXX14_CONSTEXPR 200 _Tp 201 operator()(const _Tp& __x, const _Tp& __y) const 202 { return __x / __y; } 203 }; 204 205 /// One of the @link arithmetic_functors math functors@endlink. 206 template<typename _Tp> 207 struct modulus : public binary_function<_Tp, _Tp, _Tp> 208 { 209 _GLIBCXX14_CONSTEXPR 210 _Tp 211 operator()(const _Tp& __x, const _Tp& __y) const 212 { return __x % __y; } 213 }; 214 215 /// One of the @link arithmetic_functors math functors@endlink. 216 template<typename _Tp> 217 struct negate : public unary_function<_Tp, _Tp> 218 { 219 _GLIBCXX14_CONSTEXPR 220 _Tp 221 operator()(const _Tp& __x) const 222 { return -__x; } 223 }; 224 225 #if __cplusplus > 201103L 226 227 #define __cpp_lib_transparent_operators 201210 228 //#define __cpp_lib_generic_associative_lookup 201304 229 230 template<> 231 struct plus<void> 232 { 233 template <typename _Tp, typename _Up> 234 _GLIBCXX14_CONSTEXPR 235 auto 236 operator()(_Tp&& __t, _Up&& __u) const 237 noexcept(noexcept(std::forward<_Tp>(__t) + std::forward<_Up>(__u))) 238 -> decltype(std::forward<_Tp>(__t) + std::forward<_Up>(__u)) 239 { return std::forward<_Tp>(__t) + std::forward<_Up>(__u); } 240 241 typedef __is_transparent is_transparent; 242 }; 243 244 /// One of the @link arithmetic_functors math functors@endlink. 245 template<> 246 struct minus<void> 247 { 248 template <typename _Tp, typename _Up> 249 _GLIBCXX14_CONSTEXPR 250 auto 251 operator()(_Tp&& __t, _Up&& __u) const 252 noexcept(noexcept(std::forward<_Tp>(__t) - std::forward<_Up>(__u))) 253 -> decltype(std::forward<_Tp>(__t) - std::forward<_Up>(__u)) 254 { return std::forward<_Tp>(__t) - std::forward<_Up>(__u); } 255 256 typedef __is_transparent is_transparent; 257 }; 258 259 /// One of the @link arithmetic_functors math functors@endlink. 260 template<> 261 struct multiplies<void> 262 { 263 template <typename _Tp, typename _Up> 264 _GLIBCXX14_CONSTEXPR 265 auto 266 operator()(_Tp&& __t, _Up&& __u) const 267 noexcept(noexcept(std::forward<_Tp>(__t) * std::forward<_Up>(__u))) 268 -> decltype(std::forward<_Tp>(__t) * std::forward<_Up>(__u)) 269 { return std::forward<_Tp>(__t) * std::forward<_Up>(__u); } 270 271 typedef __is_transparent is_transparent; 272 }; 273 274 /// One of the @link arithmetic_functors math functors@endlink. 275 template<> 276 struct divides<void> 277 { 278 template <typename _Tp, typename _Up> 279 _GLIBCXX14_CONSTEXPR 280 auto 281 operator()(_Tp&& __t, _Up&& __u) const 282 noexcept(noexcept(std::forward<_Tp>(__t) / std::forward<_Up>(__u))) 283 -> decltype(std::forward<_Tp>(__t) / std::forward<_Up>(__u)) 284 { return std::forward<_Tp>(__t) / std::forward<_Up>(__u); } 285 286 typedef __is_transparent is_transparent; 287 }; 288 289 /// One of the @link arithmetic_functors math functors@endlink. 290 template<> 291 struct modulus<void> 292 { 293 template <typename _Tp, typename _Up> 294 _GLIBCXX14_CONSTEXPR 295 auto 296 operator()(_Tp&& __t, _Up&& __u) const 297 noexcept(noexcept(std::forward<_Tp>(__t) % std::forward<_Up>(__u))) 298 -> decltype(std::forward<_Tp>(__t) % std::forward<_Up>(__u)) 299 { return std::forward<_Tp>(__t) % std::forward<_Up>(__u); } 300 301 typedef __is_transparent is_transparent; 302 }; 303 304 /// One of the @link arithmetic_functors math functors@endlink. 305 template<> 306 struct negate<void> 307 { 308 template <typename _Tp> 309 _GLIBCXX14_CONSTEXPR 310 auto 311 operator()(_Tp&& __t) const 312 noexcept(noexcept(-std::forward<_Tp>(__t))) 313 -> decltype(-std::forward<_Tp>(__t)) 314 { return -std::forward<_Tp>(__t); } 315 316 typedef __is_transparent is_transparent; 317 }; 318 #endif 319 /** @} */ 320 321 // 20.3.3 comparisons 322 /** @defgroup comparison_functors Comparison Classes 323 * @ingroup functors 324 * 325 * The library provides six wrapper functors for all the basic comparisons 326 * in C++, like @c <. 327 * 328 * @{ 329 */ 330 #if __cplusplus > 201103L 331 template<typename _Tp = void> 332 struct equal_to; 333 334 template<typename _Tp = void> 335 struct not_equal_to; 336 337 template<typename _Tp = void> 338 struct greater; 339 340 template<typename _Tp = void> 341 struct less; 342 343 template<typename _Tp = void> 344 struct greater_equal; 345 346 template<typename _Tp = void> 347 struct less_equal; 348 #endif 349 350 /// One of the @link comparison_functors comparison functors@endlink. 351 template<typename _Tp> 352 struct equal_to : public binary_function<_Tp, _Tp, bool> 353 { 354 _GLIBCXX14_CONSTEXPR 355 bool 356 operator()(const _Tp& __x, const _Tp& __y) const 357 { return __x == __y; } 358 }; 359 360 /// One of the @link comparison_functors comparison functors@endlink. 361 template<typename _Tp> 362 struct not_equal_to : public binary_function<_Tp, _Tp, bool> 363 { 364 _GLIBCXX14_CONSTEXPR 365 bool 366 operator()(const _Tp& __x, const _Tp& __y) const 367 { return __x != __y; } 368 }; 369 370 /// One of the @link comparison_functors comparison functors@endlink. 371 template<typename _Tp> 372 struct greater : public binary_function<_Tp, _Tp, bool> 373 { 374 _GLIBCXX14_CONSTEXPR 375 bool 376 operator()(const _Tp& __x, const _Tp& __y) const 377 { return __x > __y; } 378 }; 379 380 /// One of the @link comparison_functors comparison functors@endlink. 381 template<typename _Tp> 382 struct less : public binary_function<_Tp, _Tp, bool> 383 { 384 _GLIBCXX14_CONSTEXPR 385 bool 386 operator()(const _Tp& __x, const _Tp& __y) const 387 { return __x < __y; } 388 }; 389 390 /// One of the @link comparison_functors comparison functors@endlink. 391 template<typename _Tp> 392 struct greater_equal : public binary_function<_Tp, _Tp, bool> 393 { 394 _GLIBCXX14_CONSTEXPR 395 bool 396 operator()(const _Tp& __x, const _Tp& __y) const 397 { return __x >= __y; } 398 }; 399 400 /// One of the @link comparison_functors comparison functors@endlink. 401 template<typename _Tp> 402 struct less_equal : public binary_function<_Tp, _Tp, bool> 403 { 404 _GLIBCXX14_CONSTEXPR 405 bool 406 operator()(const _Tp& __x, const _Tp& __y) const 407 { return __x <= __y; } 408 }; 409 410 #if __cplusplus > 201103L 411 /// One of the @link comparison_functors comparison functors@endlink. 412 template<> 413 struct equal_to<void> 414 { 415 template <typename _Tp, typename _Up> 416 _GLIBCXX14_CONSTEXPR 417 auto 418 operator()(_Tp&& __t, _Up&& __u) const 419 noexcept(noexcept(std::forward<_Tp>(__t) == std::forward<_Up>(__u))) 420 -> decltype(std::forward<_Tp>(__t) == std::forward<_Up>(__u)) 421 { return std::forward<_Tp>(__t) == std::forward<_Up>(__u); } 422 423 typedef __is_transparent is_transparent; 424 }; 425 426 /// One of the @link comparison_functors comparison functors@endlink. 427 template<> 428 struct not_equal_to<void> 429 { 430 template <typename _Tp, typename _Up> 431 _GLIBCXX14_CONSTEXPR 432 auto 433 operator()(_Tp&& __t, _Up&& __u) const 434 noexcept(noexcept(std::forward<_Tp>(__t) != std::forward<_Up>(__u))) 435 -> decltype(std::forward<_Tp>(__t) != std::forward<_Up>(__u)) 436 { return std::forward<_Tp>(__t) != std::forward<_Up>(__u); } 437 438 typedef __is_transparent is_transparent; 439 }; 440 441 /// One of the @link comparison_functors comparison functors@endlink. 442 template<> 443 struct greater<void> 444 { 445 template <typename _Tp, typename _Up> 446 _GLIBCXX14_CONSTEXPR 447 auto 448 operator()(_Tp&& __t, _Up&& __u) const 449 noexcept(noexcept(std::forward<_Tp>(__t) > std::forward<_Up>(__u))) 450 -> decltype(std::forward<_Tp>(__t) > std::forward<_Up>(__u)) 451 { return std::forward<_Tp>(__t) > std::forward<_Up>(__u); } 452 453 typedef __is_transparent is_transparent; 454 }; 455 456 /// One of the @link comparison_functors comparison functors@endlink. 457 template<> 458 struct less<void> 459 { 460 template <typename _Tp, typename _Up> 461 _GLIBCXX14_CONSTEXPR 462 auto 463 operator()(_Tp&& __t, _Up&& __u) const 464 noexcept(noexcept(std::forward<_Tp>(__t) < std::forward<_Up>(__u))) 465 -> decltype(std::forward<_Tp>(__t) < std::forward<_Up>(__u)) 466 { return std::forward<_Tp>(__t) < std::forward<_Up>(__u); } 467 468 typedef __is_transparent is_transparent; 469 }; 470 471 /// One of the @link comparison_functors comparison functors@endlink. 472 template<> 473 struct greater_equal<void> 474 { 475 template <typename _Tp, typename _Up> 476 _GLIBCXX14_CONSTEXPR 477 auto 478 operator()(_Tp&& __t, _Up&& __u) const 479 noexcept(noexcept(std::forward<_Tp>(__t) >= std::forward<_Up>(__u))) 480 -> decltype(std::forward<_Tp>(__t) >= std::forward<_Up>(__u)) 481 { return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); } 482 483 typedef __is_transparent is_transparent; 484 }; 485 486 /// One of the @link comparison_functors comparison functors@endlink. 487 template<> 488 struct less_equal<void> 489 { 490 template <typename _Tp, typename _Up> 491 _GLIBCXX14_CONSTEXPR 492 auto 493 operator()(_Tp&& __t, _Up&& __u) const 494 noexcept(noexcept(std::forward<_Tp>(__t) <= std::forward<_Up>(__u))) 495 -> decltype(std::forward<_Tp>(__t) <= std::forward<_Up>(__u)) 496 { return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); } 497 498 typedef __is_transparent is_transparent; 499 }; 500 #endif 501 /** @} */ 502 503 // 20.3.4 logical operations 504 /** @defgroup logical_functors Boolean Operations Classes 505 * @ingroup functors 506 * 507 * Here are wrapper functors for Boolean operations: @c &&, @c ||, 508 * and @c !. 509 * 510 * @{ 511 */ 512 #if __cplusplus > 201103L 513 template<typename _Tp = void> 514 struct logical_and; 515 516 template<typename _Tp = void> 517 struct logical_or; 518 519 template<typename _Tp = void> 520 struct logical_not; 521 #endif 522 523 /// One of the @link logical_functors Boolean operations functors@endlink. 524 template<typename _Tp> 525 struct logical_and : public binary_function<_Tp, _Tp, bool> 526 { 527 _GLIBCXX14_CONSTEXPR 528 bool 529 operator()(const _Tp& __x, const _Tp& __y) const 530 { return __x && __y; } 531 }; 532 533 /// One of the @link logical_functors Boolean operations functors@endlink. 534 template<typename _Tp> 535 struct logical_or : public binary_function<_Tp, _Tp, bool> 536 { 537 _GLIBCXX14_CONSTEXPR 538 bool 539 operator()(const _Tp& __x, const _Tp& __y) const 540 { return __x || __y; } 541 }; 542 543 /// One of the @link logical_functors Boolean operations functors@endlink. 544 template<typename _Tp> 545 struct logical_not : public unary_function<_Tp, bool> 546 { 547 _GLIBCXX14_CONSTEXPR 548 bool 549 operator()(const _Tp& __x) const 550 { return !__x; } 551 }; 552 553 #if __cplusplus > 201103L 554 /// One of the @link logical_functors Boolean operations functors@endlink. 555 template<> 556 struct logical_and<void> 557 { 558 template <typename _Tp, typename _Up> 559 _GLIBCXX14_CONSTEXPR 560 auto 561 operator()(_Tp&& __t, _Up&& __u) const 562 noexcept(noexcept(std::forward<_Tp>(__t) && std::forward<_Up>(__u))) 563 -> decltype(std::forward<_Tp>(__t) && std::forward<_Up>(__u)) 564 { return std::forward<_Tp>(__t) && std::forward<_Up>(__u); } 565 566 typedef __is_transparent is_transparent; 567 }; 568 569 /// One of the @link logical_functors Boolean operations functors@endlink. 570 template<> 571 struct logical_or<void> 572 { 573 template <typename _Tp, typename _Up> 574 _GLIBCXX14_CONSTEXPR 575 auto 576 operator()(_Tp&& __t, _Up&& __u) const 577 noexcept(noexcept(std::forward<_Tp>(__t) || std::forward<_Up>(__u))) 578 -> decltype(std::forward<_Tp>(__t) || std::forward<_Up>(__u)) 579 { return std::forward<_Tp>(__t) || std::forward<_Up>(__u); } 580 581 typedef __is_transparent is_transparent; 582 }; 583 584 /// One of the @link logical_functors Boolean operations functors@endlink. 585 template<> 586 struct logical_not<void> 587 { 588 template <typename _Tp> 589 _GLIBCXX14_CONSTEXPR 590 auto 591 operator()(_Tp&& __t) const 592 noexcept(noexcept(!std::forward<_Tp>(__t))) 593 -> decltype(!std::forward<_Tp>(__t)) 594 { return !std::forward<_Tp>(__t); } 595 596 typedef __is_transparent is_transparent; 597 }; 598 #endif 599 /** @} */ 600 601 #if __cplusplus > 201103L 602 template<typename _Tp = void> 603 struct bit_and; 604 605 template<typename _Tp = void> 606 struct bit_or; 607 608 template<typename _Tp = void> 609 struct bit_xor; 610 611 template<typename _Tp = void> 612 struct bit_not; 613 #endif 614 615 // _GLIBCXX_RESOLVE_LIB_DEFECTS 616 // DR 660. Missing Bitwise Operations. 617 template<typename _Tp> 618 struct bit_and : public binary_function<_Tp, _Tp, _Tp> 619 { 620 _GLIBCXX14_CONSTEXPR 621 _Tp 622 operator()(const _Tp& __x, const _Tp& __y) const 623 { return __x & __y; } 624 }; 625 626 template<typename _Tp> 627 struct bit_or : public binary_function<_Tp, _Tp, _Tp> 628 { 629 _GLIBCXX14_CONSTEXPR 630 _Tp 631 operator()(const _Tp& __x, const _Tp& __y) const 632 { return __x | __y; } 633 }; 634 635 template<typename _Tp> 636 struct bit_xor : public binary_function<_Tp, _Tp, _Tp> 637 { 638 _GLIBCXX14_CONSTEXPR 639 _Tp 640 operator()(const _Tp& __x, const _Tp& __y) const 641 { return __x ^ __y; } 642 }; 643 644 template<typename _Tp> 645 struct bit_not : public unary_function<_Tp, _Tp> 646 { 647 _GLIBCXX14_CONSTEXPR 648 _Tp 649 operator()(const _Tp& __x) const 650 { return ~__x; } 651 }; 652 653 #if __cplusplus > 201103L 654 template <> 655 struct bit_and<void> 656 { 657 template <typename _Tp, typename _Up> 658 _GLIBCXX14_CONSTEXPR 659 auto 660 operator()(_Tp&& __t, _Up&& __u) const 661 noexcept(noexcept(std::forward<_Tp>(__t) & std::forward<_Up>(__u))) 662 -> decltype(std::forward<_Tp>(__t) & std::forward<_Up>(__u)) 663 { return std::forward<_Tp>(__t) & std::forward<_Up>(__u); } 664 665 typedef __is_transparent is_transparent; 666 }; 667 668 template <> 669 struct bit_or<void> 670 { 671 template <typename _Tp, typename _Up> 672 _GLIBCXX14_CONSTEXPR 673 auto 674 operator()(_Tp&& __t, _Up&& __u) const 675 noexcept(noexcept(std::forward<_Tp>(__t) | std::forward<_Up>(__u))) 676 -> decltype(std::forward<_Tp>(__t) | std::forward<_Up>(__u)) 677 { return std::forward<_Tp>(__t) | std::forward<_Up>(__u); } 678 679 typedef __is_transparent is_transparent; 680 }; 681 682 template <> 683 struct bit_xor<void> 684 { 685 template <typename _Tp, typename _Up> 686 _GLIBCXX14_CONSTEXPR 687 auto 688 operator()(_Tp&& __t, _Up&& __u) const 689 noexcept(noexcept(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u))) 690 -> decltype(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u)) 691 { return std::forward<_Tp>(__t) ^ std::forward<_Up>(__u); } 692 693 typedef __is_transparent is_transparent; 694 }; 695 696 template <> 697 struct bit_not<void> 698 { 699 template <typename _Tp> 700 _GLIBCXX14_CONSTEXPR 701 auto 702 operator()(_Tp&& __t) const 703 noexcept(noexcept(~std::forward<_Tp>(__t))) 704 -> decltype(~std::forward<_Tp>(__t)) 705 { return ~std::forward<_Tp>(__t); } 706 707 typedef __is_transparent is_transparent; 708 }; 709 #endif 710 711 // 20.3.5 negators 712 /** @defgroup negators Negators 713 * @ingroup functors 714 * 715 * The functions @c not1 and @c not2 each take a predicate functor 716 * and return an instance of @c unary_negate or 717 * @c binary_negate, respectively. These classes are functors whose 718 * @c operator() performs the stored predicate function and then returns 719 * the negation of the result. 720 * 721 * For example, given a vector of integers and a trivial predicate, 722 * \code 723 * struct IntGreaterThanThree 724 * : public std::unary_function<int, bool> 725 * { 726 * bool operator() (int x) { return x > 3; } 727 * }; 728 * 729 * std::find_if (v.begin(), v.end(), not1(IntGreaterThanThree())); 730 * \endcode 731 * The call to @c find_if will locate the first index (i) of @c v for which 732 * <code>!(v[i] > 3)</code> is true. 733 * 734 * The not1/unary_negate combination works on predicates taking a single 735 * argument. The not2/binary_negate combination works on predicates which 736 * take two arguments. 737 * 738 * @{ 739 */ 740 /// One of the @link negators negation functors@endlink. 741 template<typename _Predicate> 742 class unary_negate 743 : public unary_function<typename _Predicate::argument_type, bool> 744 { 745 protected: 746 _Predicate _M_pred; 747 748 public: 749 _GLIBCXX14_CONSTEXPR 750 explicit 751 unary_negate(const _Predicate& __x) : _M_pred(__x) { } 752 753 _GLIBCXX14_CONSTEXPR 754 bool 755 operator()(const typename _Predicate::argument_type& __x) const 756 { return !_M_pred(__x); } 757 }; 758 759 /// One of the @link negators negation functors@endlink. 760 template<typename _Predicate> 761 _GLIBCXX14_CONSTEXPR 762 inline unary_negate<_Predicate> 763 not1(const _Predicate& __pred) 764 { return unary_negate<_Predicate>(__pred); } 765 766 /// One of the @link negators negation functors@endlink. 767 template<typename _Predicate> 768 class binary_negate 769 : public binary_function<typename _Predicate::first_argument_type, 770 typename _Predicate::second_argument_type, bool> 771 { 772 protected: 773 _Predicate _M_pred; 774 775 public: 776 _GLIBCXX14_CONSTEXPR 777 explicit 778 binary_negate(const _Predicate& __x) : _M_pred(__x) { } 779 780 _GLIBCXX14_CONSTEXPR 781 bool 782 operator()(const typename _Predicate::first_argument_type& __x, 783 const typename _Predicate::second_argument_type& __y) const 784 { return !_M_pred(__x, __y); } 785 }; 786 787 /// One of the @link negators negation functors@endlink. 788 template<typename _Predicate> 789 _GLIBCXX14_CONSTEXPR 790 inline binary_negate<_Predicate> 791 not2(const _Predicate& __pred) 792 { return binary_negate<_Predicate>(__pred); } 793 /** @} */ 794 795 // 20.3.7 adaptors pointers functions 796 /** @defgroup pointer_adaptors Adaptors for pointers to functions 797 * @ingroup functors 798 * 799 * The advantage of function objects over pointers to functions is that 800 * the objects in the standard library declare nested typedefs describing 801 * their argument and result types with uniform names (e.g., @c result_type 802 * from the base classes @c unary_function and @c binary_function). 803 * Sometimes those typedefs are required, not just optional. 804 * 805 * Adaptors are provided to turn pointers to unary (single-argument) and 806 * binary (double-argument) functions into function objects. The 807 * long-winded functor @c pointer_to_unary_function is constructed with a 808 * function pointer @c f, and its @c operator() called with argument @c x 809 * returns @c f(x). The functor @c pointer_to_binary_function does the same 810 * thing, but with a double-argument @c f and @c operator(). 811 * 812 * The function @c ptr_fun takes a pointer-to-function @c f and constructs 813 * an instance of the appropriate functor. 814 * 815 * @{ 816 */ 817 /// One of the @link pointer_adaptors adaptors for function pointers@endlink. 818 template<typename _Arg, typename _Result> 819 class pointer_to_unary_function : public unary_function<_Arg, _Result> 820 { 821 protected: 822 _Result (*_M_ptr)(_Arg); 823 824 public: 825 pointer_to_unary_function() { } 826 827 explicit 828 pointer_to_unary_function(_Result (*__x)(_Arg)) 829 : _M_ptr(__x) { } 830 831 _Result 832 operator()(_Arg __x) const 833 { return _M_ptr(__x); } 834 }; 835 836 /// One of the @link pointer_adaptors adaptors for function pointers@endlink. 837 template<typename _Arg, typename _Result> 838 inline pointer_to_unary_function<_Arg, _Result> 839 ptr_fun(_Result (*__x)(_Arg)) 840 { return pointer_to_unary_function<_Arg, _Result>(__x); } 841 842 /// One of the @link pointer_adaptors adaptors for function pointers@endlink. 843 template<typename _Arg1, typename _Arg2, typename _Result> 844 class pointer_to_binary_function 845 : public binary_function<_Arg1, _Arg2, _Result> 846 { 847 protected: 848 _Result (*_M_ptr)(_Arg1, _Arg2); 849 850 public: 851 pointer_to_binary_function() { } 852 853 explicit 854 pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2)) 855 : _M_ptr(__x) { } 856 857 _Result 858 operator()(_Arg1 __x, _Arg2 __y) const 859 { return _M_ptr(__x, __y); } 860 }; 861 862 /// One of the @link pointer_adaptors adaptors for function pointers@endlink. 863 template<typename _Arg1, typename _Arg2, typename _Result> 864 inline pointer_to_binary_function<_Arg1, _Arg2, _Result> 865 ptr_fun(_Result (*__x)(_Arg1, _Arg2)) 866 { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); } 867 /** @} */ 868 869 template<typename _Tp> 870 struct _Identity 871 : public unary_function<_Tp,_Tp> 872 { 873 _Tp& 874 operator()(_Tp& __x) const 875 { return __x; } 876 877 const _Tp& 878 operator()(const _Tp& __x) const 879 { return __x; } 880 }; 881 882 template<typename _Pair> 883 struct _Select1st 884 : public unary_function<_Pair, typename _Pair::first_type> 885 { 886 typename _Pair::first_type& 887 operator()(_Pair& __x) const 888 { return __x.first; } 889 890 const typename _Pair::first_type& 891 operator()(const _Pair& __x) const 892 { return __x.first; } 893 894 #if __cplusplus >= 201103L 895 template<typename _Pair2> 896 typename _Pair2::first_type& 897 operator()(_Pair2& __x) const 898 { return __x.first; } 899 900 template<typename _Pair2> 901 const typename _Pair2::first_type& 902 operator()(const _Pair2& __x) const 903 { return __x.first; } 904 #endif 905 }; 906 907 template<typename _Pair> 908 struct _Select2nd 909 : public unary_function<_Pair, typename _Pair::second_type> 910 { 911 typename _Pair::second_type& 912 operator()(_Pair& __x) const 913 { return __x.second; } 914 915 const typename _Pair::second_type& 916 operator()(const _Pair& __x) const 917 { return __x.second; } 918 }; 919 920 // 20.3.8 adaptors pointers members 921 /** @defgroup memory_adaptors Adaptors for pointers to members 922 * @ingroup functors 923 * 924 * There are a total of 8 = 2^3 function objects in this family. 925 * (1) Member functions taking no arguments vs member functions taking 926 * one argument. 927 * (2) Call through pointer vs call through reference. 928 * (3) Const vs non-const member function. 929 * 930 * All of this complexity is in the function objects themselves. You can 931 * ignore it by using the helper function mem_fun and mem_fun_ref, 932 * which create whichever type of adaptor is appropriate. 933 * 934 * @{ 935 */ 936 /// One of the @link memory_adaptors adaptors for member 937 /// pointers@endlink. 938 template<typename _Ret, typename _Tp> 939 class mem_fun_t : public unary_function<_Tp*, _Ret> 940 { 941 public: 942 explicit 943 mem_fun_t(_Ret (_Tp::*__pf)()) 944 : _M_f(__pf) { } 945 946 _Ret 947 operator()(_Tp* __p) const 948 { return (__p->*_M_f)(); } 949 950 private: 951 _Ret (_Tp::*_M_f)(); 952 }; 953 954 /// One of the @link memory_adaptors adaptors for member 955 /// pointers@endlink. 956 template<typename _Ret, typename _Tp> 957 class const_mem_fun_t : public unary_function<const _Tp*, _Ret> 958 { 959 public: 960 explicit 961 const_mem_fun_t(_Ret (_Tp::*__pf)() const) 962 : _M_f(__pf) { } 963 964 _Ret 965 operator()(const _Tp* __p) const 966 { return (__p->*_M_f)(); } 967 968 private: 969 _Ret (_Tp::*_M_f)() const; 970 }; 971 972 /// One of the @link memory_adaptors adaptors for member 973 /// pointers@endlink. 974 template<typename _Ret, typename _Tp> 975 class mem_fun_ref_t : public unary_function<_Tp, _Ret> 976 { 977 public: 978 explicit 979 mem_fun_ref_t(_Ret (_Tp::*__pf)()) 980 : _M_f(__pf) { } 981 982 _Ret 983 operator()(_Tp& __r) const 984 { return (__r.*_M_f)(); } 985 986 private: 987 _Ret (_Tp::*_M_f)(); 988 }; 989 990 /// One of the @link memory_adaptors adaptors for member 991 /// pointers@endlink. 992 template<typename _Ret, typename _Tp> 993 class const_mem_fun_ref_t : public unary_function<_Tp, _Ret> 994 { 995 public: 996 explicit 997 const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const) 998 : _M_f(__pf) { } 999 1000 _Ret 1001 operator()(const _Tp& __r) const 1002 { return (__r.*_M_f)(); } 1003 1004 private: 1005 _Ret (_Tp::*_M_f)() const; 1006 }; 1007 1008 /// One of the @link memory_adaptors adaptors for member 1009 /// pointers@endlink. 1010 template<typename _Ret, typename _Tp, typename _Arg> 1011 class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret> 1012 { 1013 public: 1014 explicit 1015 mem_fun1_t(_Ret (_Tp::*__pf)(_Arg)) 1016 : _M_f(__pf) { } 1017 1018 _Ret 1019 operator()(_Tp* __p, _Arg __x) const 1020 { return (__p->*_M_f)(__x); } 1021 1022 private: 1023 _Ret (_Tp::*_M_f)(_Arg); 1024 }; 1025 1026 /// One of the @link memory_adaptors adaptors for member 1027 /// pointers@endlink. 1028 template<typename _Ret, typename _Tp, typename _Arg> 1029 class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret> 1030 { 1031 public: 1032 explicit 1033 const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const) 1034 : _M_f(__pf) { } 1035 1036 _Ret 1037 operator()(const _Tp* __p, _Arg __x) const 1038 { return (__p->*_M_f)(__x); } 1039 1040 private: 1041 _Ret (_Tp::*_M_f)(_Arg) const; 1042 }; 1043 1044 /// One of the @link memory_adaptors adaptors for member 1045 /// pointers@endlink. 1046 template<typename _Ret, typename _Tp, typename _Arg> 1047 class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> 1048 { 1049 public: 1050 explicit 1051 mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg)) 1052 : _M_f(__pf) { } 1053 1054 _Ret 1055 operator()(_Tp& __r, _Arg __x) const 1056 { return (__r.*_M_f)(__x); } 1057 1058 private: 1059 _Ret (_Tp::*_M_f)(_Arg); 1060 }; 1061 1062 /// One of the @link memory_adaptors adaptors for member 1063 /// pointers@endlink. 1064 template<typename _Ret, typename _Tp, typename _Arg> 1065 class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> 1066 { 1067 public: 1068 explicit 1069 const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const) 1070 : _M_f(__pf) { } 1071 1072 _Ret 1073 operator()(const _Tp& __r, _Arg __x) const 1074 { return (__r.*_M_f)(__x); } 1075 1076 private: 1077 _Ret (_Tp::*_M_f)(_Arg) const; 1078 }; 1079 1080 // Mem_fun adaptor helper functions. There are only two: 1081 // mem_fun and mem_fun_ref. 1082 template<typename _Ret, typename _Tp> 1083 inline mem_fun_t<_Ret, _Tp> 1084 mem_fun(_Ret (_Tp::*__f)()) 1085 { return mem_fun_t<_Ret, _Tp>(__f); } 1086 1087 template<typename _Ret, typename _Tp> 1088 inline const_mem_fun_t<_Ret, _Tp> 1089 mem_fun(_Ret (_Tp::*__f)() const) 1090 { return const_mem_fun_t<_Ret, _Tp>(__f); } 1091 1092 template<typename _Ret, typename _Tp> 1093 inline mem_fun_ref_t<_Ret, _Tp> 1094 mem_fun_ref(_Ret (_Tp::*__f)()) 1095 { return mem_fun_ref_t<_Ret, _Tp>(__f); } 1096 1097 template<typename _Ret, typename _Tp> 1098 inline const_mem_fun_ref_t<_Ret, _Tp> 1099 mem_fun_ref(_Ret (_Tp::*__f)() const) 1100 { return const_mem_fun_ref_t<_Ret, _Tp>(__f); } 1101 1102 template<typename _Ret, typename _Tp, typename _Arg> 1103 inline mem_fun1_t<_Ret, _Tp, _Arg> 1104 mem_fun(_Ret (_Tp::*__f)(_Arg)) 1105 { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); } 1106 1107 template<typename _Ret, typename _Tp, typename _Arg> 1108 inline const_mem_fun1_t<_Ret, _Tp, _Arg> 1109 mem_fun(_Ret (_Tp::*__f)(_Arg) const) 1110 { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); } 1111 1112 template<typename _Ret, typename _Tp, typename _Arg> 1113 inline mem_fun1_ref_t<_Ret, _Tp, _Arg> 1114 mem_fun_ref(_Ret (_Tp::*__f)(_Arg)) 1115 { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } 1116 1117 template<typename _Ret, typename _Tp, typename _Arg> 1118 inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg> 1119 mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const) 1120 { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } 1121 1122 /** @} */ 1123 1124 _GLIBCXX_END_NAMESPACE_VERSION 1125 } // namespace 1126 1127 #if (__cplusplus < 201103L) || _GLIBCXX_USE_DEPRECATED 1128 # include <backward/binders.h> 1129 #endif 1130 1131 #endif /* _STL_FUNCTION_H */ 1132