contrib/gcc-5.0/libstdc++-v3/include/bits/stl_function.h

   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 */