l4/pkg/libstdc++-v3/contrib/libstdc++-v3-4.9/include/bits/stl_function.h

   1 // Functor implementations -*- C++ -*-
   2
   3 // Copyright (C) 2001-2014 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       _Tp
 170       operator()(const _Tp& __x, const _Tp& __y) const
 171       { return __x + __y; }
 172     };
 173
 174   /// One of the @link arithmetic_functors math functors@endlink.
 175   template<typename _Tp>
 176     struct minus : public binary_function<_Tp, _Tp, _Tp>
 177     {
 178       _Tp
 179       operator()(const _Tp& __x, const _Tp& __y) const
 180       { return __x - __y; }
 181     };
 182
 183   /// One of the @link arithmetic_functors math functors@endlink.
 184   template<typename _Tp>
 185     struct multiplies : public binary_function<_Tp, _Tp, _Tp>
 186     {
 187       _Tp
 188       operator()(const _Tp& __x, const _Tp& __y) const
 189       { return __x * __y; }
 190     };
 191
 192   /// One of the @link arithmetic_functors math functors@endlink.
 193   template<typename _Tp>
 194     struct divides : public binary_function<_Tp, _Tp, _Tp>
 195     {
 196       _Tp
 197       operator()(const _Tp& __x, const _Tp& __y) const
 198       { return __x / __y; }
 199     };
 200
 201   /// One of the @link arithmetic_functors math functors@endlink.
 202   template<typename _Tp>
 203     struct modulus : public binary_function<_Tp, _Tp, _Tp>
 204     {
 205       _Tp
 206       operator()(const _Tp& __x, const _Tp& __y) const
 207       { return __x % __y; }
 208     };
 209
 210   /// One of the @link arithmetic_functors math functors@endlink.
 211   template<typename _Tp>
 212     struct negate : public unary_function<_Tp, _Tp>
 213     {
 214       _Tp
 215       operator()(const _Tp& __x) const
 216       { return -__x; }
 217     };
 218
 219 #if __cplusplus > 201103L
 220   template<>
 221     struct plus<void>
 222     {
 223       template <typename _Tp, typename _Up>
 224         auto
 225         operator()(_Tp&& __t, _Up&& __u) const
 226         noexcept(noexcept(std::forward<_Tp>(__t) + std::forward<_Up>(__u)))
 227         -> decltype(std::forward<_Tp>(__t) + std::forward<_Up>(__u))
 228         { return std::forward<_Tp>(__t) + std::forward<_Up>(__u); }
 229
 230       typedef __is_transparent is_transparent;
 231     };
 232
 233   /// One of the @link arithmetic_functors math functors@endlink.
 234   template<>
 235     struct minus<void>
 236     {
 237       template <typename _Tp, typename _Up>
 238         auto
 239         operator()(_Tp&& __t, _Up&& __u) const
 240         noexcept(noexcept(std::forward<_Tp>(__t) - std::forward<_Up>(__u)))
 241         -> decltype(std::forward<_Tp>(__t) - std::forward<_Up>(__u))
 242         { return std::forward<_Tp>(__t) - std::forward<_Up>(__u); }
 243
 244       typedef __is_transparent is_transparent;
 245     };
 246
 247   /// One of the @link arithmetic_functors math functors@endlink.
 248   template<>
 249     struct multiplies<void>
 250     {
 251       template <typename _Tp, typename _Up>
 252         auto
 253         operator()(_Tp&& __t, _Up&& __u) const
 254         noexcept(noexcept(std::forward<_Tp>(__t) * std::forward<_Up>(__u)))
 255         -> decltype(std::forward<_Tp>(__t) * std::forward<_Up>(__u))
 256         { return std::forward<_Tp>(__t) * std::forward<_Up>(__u); }
 257
 258       typedef __is_transparent is_transparent;
 259     };
 260
 261   /// One of the @link arithmetic_functors math functors@endlink.
 262   template<>
 263     struct divides<void>
 264     {
 265       template <typename _Tp, typename _Up>
 266         auto
 267         operator()(_Tp&& __t, _Up&& __u) const
 268         noexcept(noexcept(std::forward<_Tp>(__t) / std::forward<_Up>(__u)))
 269         -> decltype(std::forward<_Tp>(__t) / std::forward<_Up>(__u))
 270         { return std::forward<_Tp>(__t) / std::forward<_Up>(__u); }
 271
 272       typedef __is_transparent is_transparent;
 273     };
 274
 275   /// One of the @link arithmetic_functors math functors@endlink.
 276   template<>
 277     struct modulus<void>
 278     {
 279       template <typename _Tp, typename _Up>
 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 negate<void>
 292     {
 293       template <typename _Tp>
 294         auto
 295         operator()(_Tp&& __t) const
 296         noexcept(noexcept(-std::forward<_Tp>(__t)))
 297         -> decltype(-std::forward<_Tp>(__t))
 298         { return -std::forward<_Tp>(__t); }
 299
 300       typedef __is_transparent is_transparent;
 301     };
 302 #endif
 303   /** @}  */
 304
 305   // 20.3.3 comparisons
 306   /** @defgroup comparison_functors Comparison Classes
 307    * @ingroup functors
 308    *
 309    *  The library provides six wrapper functors for all the basic comparisons
 310    *  in C++, like @c <.
 311    *
 312    *  @{
 313    */
 314 #if __cplusplus > 201103L
 315   template<typename _Tp = void>
 316     struct equal_to;
 317
 318   template<typename _Tp = void>
 319     struct not_equal_to;
 320
 321   template<typename _Tp = void>
 322     struct greater;
 323
 324   template<typename _Tp = void>
 325     struct less;
 326
 327   template<typename _Tp = void>
 328     struct greater_equal;
 329
 330   template<typename _Tp = void>
 331     struct less_equal;
 332 #endif
 333
 334   /// One of the @link comparison_functors comparison functors@endlink.
 335   template<typename _Tp>
 336     struct equal_to : public binary_function<_Tp, _Tp, bool>
 337     {
 338       bool
 339       operator()(const _Tp& __x, const _Tp& __y) const
 340       { return __x == __y; }
 341     };
 342
 343   /// One of the @link comparison_functors comparison functors@endlink.
 344   template<typename _Tp>
 345     struct not_equal_to : public binary_function<_Tp, _Tp, bool>
 346     {
 347       bool
 348       operator()(const _Tp& __x, const _Tp& __y) const
 349       { return __x != __y; }
 350     };
 351
 352   /// One of the @link comparison_functors comparison functors@endlink.
 353   template<typename _Tp>
 354     struct greater : public binary_function<_Tp, _Tp, bool>
 355     {
 356       bool
 357       operator()(const _Tp& __x, const _Tp& __y) const
 358       { return __x > __y; }
 359     };
 360
 361   /// One of the @link comparison_functors comparison functors@endlink.
 362   template<typename _Tp>
 363     struct less : public binary_function<_Tp, _Tp, bool>
 364     {
 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_equal : public binary_function<_Tp, _Tp, bool>
 373     {
 374       bool
 375       operator()(const _Tp& __x, const _Tp& __y) const
 376       { return __x >= __y; }
 377     };
 378
 379   /// One of the @link comparison_functors comparison functors@endlink.
 380   template<typename _Tp>
 381     struct less_equal : public binary_function<_Tp, _Tp, bool>
 382     {
 383       bool
 384       operator()(const _Tp& __x, const _Tp& __y) const
 385       { return __x <= __y; }
 386     };
 387
 388 #if __cplusplus > 201103L
 389   /// One of the @link comparison_functors comparison functors@endlink.
 390   template<>
 391     struct equal_to<void>
 392     {
 393       template <typename _Tp, typename _Up>
 394         auto
 395         operator()(_Tp&& __t, _Up&& __u) const
 396         noexcept(noexcept(std::forward<_Tp>(__t) == std::forward<_Up>(__u)))
 397         -> decltype(std::forward<_Tp>(__t) == std::forward<_Up>(__u))
 398         { return std::forward<_Tp>(__t) == std::forward<_Up>(__u); }
 399
 400       typedef __is_transparent is_transparent;
 401     };
 402
 403   /// One of the @link comparison_functors comparison functors@endlink.
 404   template<>
 405     struct not_equal_to<void>
 406     {
 407       template <typename _Tp, typename _Up>
 408         auto
 409         operator()(_Tp&& __t, _Up&& __u) const
 410         noexcept(noexcept(std::forward<_Tp>(__t) != std::forward<_Up>(__u)))
 411         -> decltype(std::forward<_Tp>(__t) != std::forward<_Up>(__u))
 412         { return std::forward<_Tp>(__t) != std::forward<_Up>(__u); }
 413
 414       typedef __is_transparent is_transparent;
 415     };
 416
 417   /// One of the @link comparison_functors comparison functors@endlink.
 418   template<>
 419     struct greater<void>
 420     {
 421       template <typename _Tp, typename _Up>
 422         auto
 423         operator()(_Tp&& __t, _Up&& __u) const
 424         noexcept(noexcept(std::forward<_Tp>(__t) > std::forward<_Up>(__u)))
 425         -> decltype(std::forward<_Tp>(__t) > std::forward<_Up>(__u))
 426         { return std::forward<_Tp>(__t) > std::forward<_Up>(__u); }
 427
 428       typedef __is_transparent is_transparent;
 429     };
 430
 431   /// One of the @link comparison_functors comparison functors@endlink.
 432   template<>
 433     struct less<void>
 434     {
 435       template <typename _Tp, typename _Up>
 436         auto
 437         operator()(_Tp&& __t, _Up&& __u) const
 438         noexcept(noexcept(std::forward<_Tp>(__t) < std::forward<_Up>(__u)))
 439         -> decltype(std::forward<_Tp>(__t) < std::forward<_Up>(__u))
 440         { return std::forward<_Tp>(__t) < std::forward<_Up>(__u); }
 441
 442       typedef __is_transparent is_transparent;
 443     };
 444
 445   /// One of the @link comparison_functors comparison functors@endlink.
 446   template<>
 447     struct greater_equal<void>
 448     {
 449       template <typename _Tp, typename _Up>
 450         auto
 451         operator()(_Tp&& __t, _Up&& __u) const
 452         noexcept(noexcept(std::forward<_Tp>(__t) >= std::forward<_Up>(__u)))
 453         -> decltype(std::forward<_Tp>(__t) >= std::forward<_Up>(__u))
 454         { return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); }
 455
 456       typedef __is_transparent is_transparent;
 457     };
 458
 459   /// One of the @link comparison_functors comparison functors@endlink.
 460   template<>
 461     struct less_equal<void>
 462     {
 463       template <typename _Tp, typename _Up>
 464         auto
 465         operator()(_Tp&& __t, _Up&& __u) const
 466         noexcept(noexcept(std::forward<_Tp>(__t) <= std::forward<_Up>(__u)))
 467         -> decltype(std::forward<_Tp>(__t) <= std::forward<_Up>(__u))
 468         { return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); }
 469
 470       typedef __is_transparent is_transparent;
 471     };
 472 #endif
 473   /** @}  */
 474
 475   // 20.3.4 logical operations
 476   /** @defgroup logical_functors Boolean Operations Classes
 477    * @ingroup functors
 478    *
 479    *  Here are wrapper functors for Boolean operations: @c &&, @c ||,
 480    *  and @c !.
 481    *
 482    *  @{
 483    */
 484 #if __cplusplus > 201103L
 485   template<typename _Tp = void>
 486     struct logical_and;
 487
 488   template<typename _Tp = void>
 489     struct logical_or;
 490
 491   template<typename _Tp = void>
 492     struct logical_not;
 493 #endif
 494
 495   /// One of the @link logical_functors Boolean operations functors@endlink.
 496   template<typename _Tp>
 497     struct logical_and : public binary_function<_Tp, _Tp, bool>
 498     {
 499       bool
 500       operator()(const _Tp& __x, const _Tp& __y) const
 501       { return __x && __y; }
 502     };
 503
 504   /// One of the @link logical_functors Boolean operations functors@endlink.
 505   template<typename _Tp>
 506     struct logical_or : public binary_function<_Tp, _Tp, bool>
 507     {
 508       bool
 509       operator()(const _Tp& __x, const _Tp& __y) const
 510       { return __x || __y; }
 511     };
 512
 513   /// One of the @link logical_functors Boolean operations functors@endlink.
 514   template<typename _Tp>
 515     struct logical_not : public unary_function<_Tp, bool>
 516     {
 517       bool
 518       operator()(const _Tp& __x) const
 519       { return !__x; }
 520     };
 521
 522 #if __cplusplus > 201103L
 523   /// One of the @link logical_functors Boolean operations functors@endlink.
 524   template<>
 525     struct logical_and<void>
 526     {
 527       template <typename _Tp, typename _Up>
 528         auto
 529         operator()(_Tp&& __t, _Up&& __u) const
 530         noexcept(noexcept(std::forward<_Tp>(__t) && std::forward<_Up>(__u)))
 531         -> decltype(std::forward<_Tp>(__t) && std::forward<_Up>(__u))
 532         { return std::forward<_Tp>(__t) && std::forward<_Up>(__u); }
 533
 534       typedef __is_transparent is_transparent;
 535     };
 536
 537   /// One of the @link logical_functors Boolean operations functors@endlink.
 538   template<>
 539     struct logical_or<void>
 540     {
 541       template <typename _Tp, typename _Up>
 542         auto
 543         operator()(_Tp&& __t, _Up&& __u) const
 544         noexcept(noexcept(std::forward<_Tp>(__t) || std::forward<_Up>(__u)))
 545         -> decltype(std::forward<_Tp>(__t) || std::forward<_Up>(__u))
 546         { return std::forward<_Tp>(__t) || std::forward<_Up>(__u); }
 547
 548       typedef __is_transparent is_transparent;
 549     };
 550
 551   /// One of the @link logical_functors Boolean operations functors@endlink.
 552   template<>
 553     struct logical_not<void>
 554     {
 555       template <typename _Tp>
 556         auto
 557         operator()(_Tp&& __t) const
 558         noexcept(noexcept(!std::forward<_Tp>(__t)))
 559         -> decltype(!std::forward<_Tp>(__t))
 560         { return !std::forward<_Tp>(__t); }
 561
 562       typedef __is_transparent is_transparent;
 563     };
 564 #endif
 565   /** @}  */
 566
 567 #if __cplusplus > 201103L
 568   template<typename _Tp = void>
 569     struct bit_and;
 570
 571   template<typename _Tp = void>
 572     struct bit_or;
 573
 574   template<typename _Tp = void>
 575     struct bit_xor;
 576
 577   template<typename _Tp = void>
 578     struct bit_not;
 579 #endif
 580
 581   // _GLIBCXX_RESOLVE_LIB_DEFECTS
 582   // DR 660. Missing Bitwise Operations.
 583   template<typename _Tp>
 584     struct bit_and : public binary_function<_Tp, _Tp, _Tp>
 585     {
 586       _Tp
 587       operator()(const _Tp& __x, const _Tp& __y) const
 588       { return __x & __y; }
 589     };
 590
 591   template<typename _Tp>
 592     struct bit_or : public binary_function<_Tp, _Tp, _Tp>
 593     {
 594       _Tp
 595       operator()(const _Tp& __x, const _Tp& __y) const
 596       { return __x | __y; }
 597     };
 598
 599   template<typename _Tp>
 600     struct bit_xor : public binary_function<_Tp, _Tp, _Tp>
 601     {
 602       _Tp
 603       operator()(const _Tp& __x, const _Tp& __y) const
 604       { return __x ^ __y; }
 605     };
 606
 607   template<typename _Tp>
 608     struct bit_not : public unary_function<_Tp, _Tp>
 609     {
 610       _Tp
 611       operator()(const _Tp& __x) const
 612       { return ~__x; }
 613     };
 614
 615 #if __cplusplus > 201103L
 616   template <>
 617     struct bit_and<void>
 618     {
 619       template <typename _Tp, typename _Up>
 620         auto
 621         operator()(_Tp&& __t, _Up&& __u) const
 622         noexcept(noexcept(std::forward<_Tp>(__t) & std::forward<_Up>(__u)))
 623         -> decltype(std::forward<_Tp>(__t) & std::forward<_Up>(__u))
 624         { return std::forward<_Tp>(__t) & std::forward<_Up>(__u); }
 625
 626       typedef __is_transparent is_transparent;
 627     };
 628
 629   template <>
 630     struct bit_or<void>
 631     {
 632       template <typename _Tp, typename _Up>
 633         auto
 634         operator()(_Tp&& __t, _Up&& __u) const
 635         noexcept(noexcept(std::forward<_Tp>(__t) | std::forward<_Up>(__u)))
 636         -> decltype(std::forward<_Tp>(__t) | std::forward<_Up>(__u))
 637         { return std::forward<_Tp>(__t) | std::forward<_Up>(__u); }
 638
 639       typedef __is_transparent is_transparent;
 640     };
 641
 642   template <>
 643     struct bit_xor<void>
 644     {
 645       template <typename _Tp, typename _Up>
 646         auto
 647         operator()(_Tp&& __t, _Up&& __u) const
 648         noexcept(noexcept(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u)))
 649         -> decltype(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u))
 650         { return std::forward<_Tp>(__t) ^ std::forward<_Up>(__u); }
 651
 652       typedef __is_transparent is_transparent;
 653     };
 654
 655   template <>
 656     struct bit_not<void>
 657     {
 658       template <typename _Tp>
 659         auto
 660         operator()(_Tp&& __t) const
 661         noexcept(noexcept(~std::forward<_Tp>(__t)))
 662         -> decltype(~std::forward<_Tp>(__t))
 663         { return ~std::forward<_Tp>(__t); }
 664
 665       typedef __is_transparent is_transparent;
 666     };
 667 #endif
 668
 669   // 20.3.5 negators
 670   /** @defgroup negators Negators
 671    * @ingroup functors
 672    *
 673    *  The functions @c not1 and @c not2 each take a predicate functor
 674    *  and return an instance of @c unary_negate or
 675    *  @c binary_negate, respectively.  These classes are functors whose
 676    *  @c operator() performs the stored predicate function and then returns
 677    *  the negation of the result.
 678    *
 679    *  For example, given a vector of integers and a trivial predicate,
 680    *  \code
 681    *  struct IntGreaterThanThree
 682    *    : public std::unary_function<int, bool>
 683    *  {
 684    *      bool operator() (int x) { return x > 3; }
 685    *  };
 686    *
 687    *  std::find_if (v.begin(), v.end(), not1(IntGreaterThanThree()));
 688    *  \endcode
 689    *  The call to @c find_if will locate the first index (i) of @c v for which
 690    *  <code>!(v[i] > 3)</code> is true.
 691    *
 692    *  The not1/unary_negate combination works on predicates taking a single
 693    *  argument.  The not2/binary_negate combination works on predicates which
 694    *  take two arguments.
 695    *
 696    *  @{
 697    */
 698   /// One of the @link negators negation functors@endlink.
 699   template<typename _Predicate>
 700     class unary_negate
 701     : public unary_function<typename _Predicate::argument_type, bool>
 702     {
 703     protected:
 704       _Predicate _M_pred;
 705
 706     public:
 707       explicit
 708       unary_negate(const _Predicate& __x) : _M_pred(__x) { }
 709
 710       bool
 711       operator()(const typename _Predicate::argument_type& __x) const
 712       { return !_M_pred(__x); }
 713     };
 714
 715   /// One of the @link negators negation functors@endlink.
 716   template<typename _Predicate>
 717     inline unary_negate<_Predicate>
 718     not1(const _Predicate& __pred)
 719     { return unary_negate<_Predicate>(__pred); }
 720
 721   /// One of the @link negators negation functors@endlink.
 722   template<typename _Predicate>
 723     class binary_negate
 724     : public binary_function<typename _Predicate::first_argument_type,
 725                              typename _Predicate::second_argument_type, bool>
 726     {
 727     protected:
 728       _Predicate _M_pred;
 729
 730     public:
 731       explicit
 732       binary_negate(const _Predicate& __x) : _M_pred(__x) { }
 733
 734       bool
 735       operator()(const typename _Predicate::first_argument_type& __x,
 736                  const typename _Predicate::second_argument_type& __y) const
 737       { return !_M_pred(__x, __y); }
 738     };
 739
 740   /// One of the @link negators negation functors@endlink.
 741   template<typename _Predicate>
 742     inline binary_negate<_Predicate>
 743     not2(const _Predicate& __pred)
 744     { return binary_negate<_Predicate>(__pred); }
 745   /** @}  */
 746
 747   // 20.3.7 adaptors pointers functions
 748   /** @defgroup pointer_adaptors Adaptors for pointers to functions
 749    * @ingroup functors
 750    *
 751    *  The advantage of function objects over pointers to functions is that
 752    *  the objects in the standard library declare nested typedefs describing
 753    *  their argument and result types with uniform names (e.g., @c result_type
 754    *  from the base classes @c unary_function and @c binary_function).
 755    *  Sometimes those typedefs are required, not just optional.
 756    *
 757    *  Adaptors are provided to turn pointers to unary (single-argument) and
 758    *  binary (double-argument) functions into function objects.  The
 759    *  long-winded functor @c pointer_to_unary_function is constructed with a
 760    *  function pointer @c f, and its @c operator() called with argument @c x
 761    *  returns @c f(x).  The functor @c pointer_to_binary_function does the same
 762    *  thing, but with a double-argument @c f and @c operator().
 763    *
 764    *  The function @c ptr_fun takes a pointer-to-function @c f and constructs
 765    *  an instance of the appropriate functor.
 766    *
 767    *  @{
 768    */
 769   /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
 770   template<typename _Arg, typename _Result>
 771     class pointer_to_unary_function : public unary_function<_Arg, _Result>
 772     {
 773     protected:
 774       _Result (*_M_ptr)(_Arg);
 775
 776     public:
 777       pointer_to_unary_function() { }
 778
 779       explicit
 780       pointer_to_unary_function(_Result (*__x)(_Arg))
 781       : _M_ptr(__x) { }
 782
 783       _Result
 784       operator()(_Arg __x) const
 785       { return _M_ptr(__x); }
 786     };
 787
 788   /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
 789   template<typename _Arg, typename _Result>
 790     inline pointer_to_unary_function<_Arg, _Result>
 791     ptr_fun(_Result (*__x)(_Arg))
 792     { return pointer_to_unary_function<_Arg, _Result>(__x); }
 793
 794   /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
 795   template<typename _Arg1, typename _Arg2, typename _Result>
 796     class pointer_to_binary_function
 797     : public binary_function<_Arg1, _Arg2, _Result>
 798     {
 799     protected:
 800       _Result (*_M_ptr)(_Arg1, _Arg2);
 801
 802     public:
 803       pointer_to_binary_function() { }
 804
 805       explicit
 806       pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
 807       : _M_ptr(__x) { }
 808
 809       _Result
 810       operator()(_Arg1 __x, _Arg2 __y) const
 811       { return _M_ptr(__x, __y); }
 812     };
 813
 814   /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
 815   template<typename _Arg1, typename _Arg2, typename _Result>
 816     inline pointer_to_binary_function<_Arg1, _Arg2, _Result>
 817     ptr_fun(_Result (*__x)(_Arg1, _Arg2))
 818     { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); }
 819   /** @}  */
 820
 821   template<typename _Tp>
 822     struct _Identity
 823     : public unary_function<_Tp,_Tp>
 824     {
 825       _Tp&
 826       operator()(_Tp& __x) const
 827       { return __x; }
 828
 829       const _Tp&
 830       operator()(const _Tp& __x) const
 831       { return __x; }
 832     };
 833
 834   template<typename _Pair>
 835     struct _Select1st
 836     : public unary_function<_Pair, typename _Pair::first_type>
 837     {
 838       typename _Pair::first_type&
 839       operator()(_Pair& __x) const
 840       { return __x.first; }
 841
 842       const typename _Pair::first_type&
 843       operator()(const _Pair& __x) const
 844       { return __x.first; }
 845
 846 #if __cplusplus >= 201103L
 847       template<typename _Pair2>
 848         typename _Pair2::first_type&
 849         operator()(_Pair2& __x) const
 850         { return __x.first; }
 851
 852       template<typename _Pair2>
 853         const typename _Pair2::first_type&
 854         operator()(const _Pair2& __x) const
 855         { return __x.first; }
 856 #endif
 857     };
 858
 859   template<typename _Pair>
 860     struct _Select2nd
 861     : public unary_function<_Pair, typename _Pair::second_type>
 862     {
 863       typename _Pair::second_type&
 864       operator()(_Pair& __x) const
 865       { return __x.second; }
 866
 867       const typename _Pair::second_type&
 868       operator()(const _Pair& __x) const
 869       { return __x.second; }
 870     };
 871
 872   // 20.3.8 adaptors pointers members
 873   /** @defgroup memory_adaptors Adaptors for pointers to members
 874    * @ingroup functors
 875    *
 876    *  There are a total of 8 = 2^3 function objects in this family.
 877    *   (1) Member functions taking no arguments vs member functions taking
 878    *        one argument.
 879    *   (2) Call through pointer vs call through reference.
 880    *   (3) Const vs non-const member function.
 881    *
 882    *  All of this complexity is in the function objects themselves.  You can
 883    *   ignore it by using the helper function mem_fun and mem_fun_ref,
 884    *   which create whichever type of adaptor is appropriate.
 885    *
 886    *  @{
 887    */
 888   /// One of the @link memory_adaptors adaptors for member
 889   /// pointers@endlink.
 890   template<typename _Ret, typename _Tp>
 891     class mem_fun_t : public unary_function<_Tp*, _Ret>
 892     {
 893     public:
 894       explicit
 895       mem_fun_t(_Ret (_Tp::*__pf)())
 896       : _M_f(__pf) { }
 897
 898       _Ret
 899       operator()(_Tp* __p) const
 900       { return (__p->*_M_f)(); }
 901
 902     private:
 903       _Ret (_Tp::*_M_f)();
 904     };
 905
 906   /// One of the @link memory_adaptors adaptors for member
 907   /// pointers@endlink.
 908   template<typename _Ret, typename _Tp>
 909     class const_mem_fun_t : public unary_function<const _Tp*, _Ret>
 910     {
 911     public:
 912       explicit
 913       const_mem_fun_t(_Ret (_Tp::*__pf)() const)
 914       : _M_f(__pf) { }
 915
 916       _Ret
 917       operator()(const _Tp* __p) const
 918       { return (__p->*_M_f)(); }
 919
 920     private:
 921       _Ret (_Tp::*_M_f)() const;
 922     };
 923
 924   /// One of the @link memory_adaptors adaptors for member
 925   /// pointers@endlink.
 926   template<typename _Ret, typename _Tp>
 927     class mem_fun_ref_t : public unary_function<_Tp, _Ret>
 928     {
 929     public:
 930       explicit
 931       mem_fun_ref_t(_Ret (_Tp::*__pf)())
 932       : _M_f(__pf) { }
 933
 934       _Ret
 935       operator()(_Tp& __r) const
 936       { return (__r.*_M_f)(); }
 937
 938     private:
 939       _Ret (_Tp::*_M_f)();
 940   };
 941
 942   /// One of the @link memory_adaptors adaptors for member
 943   /// pointers@endlink.
 944   template<typename _Ret, typename _Tp>
 945     class const_mem_fun_ref_t : public unary_function<_Tp, _Ret>
 946     {
 947     public:
 948       explicit
 949       const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const)
 950       : _M_f(__pf) { }
 951
 952       _Ret
 953       operator()(const _Tp& __r) const
 954       { return (__r.*_M_f)(); }
 955
 956     private:
 957       _Ret (_Tp::*_M_f)() const;
 958     };
 959
 960   /// One of the @link memory_adaptors adaptors for member
 961   /// pointers@endlink.
 962   template<typename _Ret, typename _Tp, typename _Arg>
 963     class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret>
 964     {
 965     public:
 966       explicit
 967       mem_fun1_t(_Ret (_Tp::*__pf)(_Arg))
 968       : _M_f(__pf) { }
 969
 970       _Ret
 971       operator()(_Tp* __p, _Arg __x) const
 972       { return (__p->*_M_f)(__x); }
 973
 974     private:
 975       _Ret (_Tp::*_M_f)(_Arg);
 976     };
 977
 978   /// One of the @link memory_adaptors adaptors for member
 979   /// pointers@endlink.
 980   template<typename _Ret, typename _Tp, typename _Arg>
 981     class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret>
 982     {
 983     public:
 984       explicit
 985       const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const)
 986       : _M_f(__pf) { }
 987
 988       _Ret
 989       operator()(const _Tp* __p, _Arg __x) const
 990       { return (__p->*_M_f)(__x); }
 991
 992     private:
 993       _Ret (_Tp::*_M_f)(_Arg) const;
 994     };
 995
 996   /// One of the @link memory_adaptors adaptors for member
 997   /// pointers@endlink.
 998   template<typename _Ret, typename _Tp, typename _Arg>
 999     class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
1000     {
1001     public:
1002       explicit
1003       mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg))
1004       : _M_f(__pf) { }
1005
1006       _Ret
1007       operator()(_Tp& __r, _Arg __x) const
1008       { return (__r.*_M_f)(__x); }
1009
1010     private:
1011       _Ret (_Tp::*_M_f)(_Arg);
1012     };
1013
1014   /// One of the @link memory_adaptors adaptors for member
1015   /// pointers@endlink.
1016   template<typename _Ret, typename _Tp, typename _Arg>
1017     class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
1018     {
1019     public:
1020       explicit
1021       const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const)
1022       : _M_f(__pf) { }
1023
1024       _Ret
1025       operator()(const _Tp& __r, _Arg __x) const
1026       { return (__r.*_M_f)(__x); }
1027
1028     private:
1029       _Ret (_Tp::*_M_f)(_Arg) const;
1030     };
1031
1032   // Mem_fun adaptor helper functions.  There are only two:
1033   // mem_fun and mem_fun_ref.
1034   template<typename _Ret, typename _Tp>
1035     inline mem_fun_t<_Ret, _Tp>
1036     mem_fun(_Ret (_Tp::*__f)())
1037     { return mem_fun_t<_Ret, _Tp>(__f); }
1038
1039   template<typename _Ret, typename _Tp>
1040     inline const_mem_fun_t<_Ret, _Tp>
1041     mem_fun(_Ret (_Tp::*__f)() const)
1042     { return const_mem_fun_t<_Ret, _Tp>(__f); }
1043
1044   template<typename _Ret, typename _Tp>
1045     inline mem_fun_ref_t<_Ret, _Tp>
1046     mem_fun_ref(_Ret (_Tp::*__f)())
1047     { return mem_fun_ref_t<_Ret, _Tp>(__f); }
1048
1049   template<typename _Ret, typename _Tp>
1050     inline const_mem_fun_ref_t<_Ret, _Tp>
1051     mem_fun_ref(_Ret (_Tp::*__f)() const)
1052     { return const_mem_fun_ref_t<_Ret, _Tp>(__f); }
1053
1054   template<typename _Ret, typename _Tp, typename _Arg>
1055     inline mem_fun1_t<_Ret, _Tp, _Arg>
1056     mem_fun(_Ret (_Tp::*__f)(_Arg))
1057     { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
1058
1059   template<typename _Ret, typename _Tp, typename _Arg>
1060     inline const_mem_fun1_t<_Ret, _Tp, _Arg>
1061     mem_fun(_Ret (_Tp::*__f)(_Arg) const)
1062     { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
1063
1064   template<typename _Ret, typename _Tp, typename _Arg>
1065     inline mem_fun1_ref_t<_Ret, _Tp, _Arg>
1066     mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
1067     { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
1068
1069   template<typename _Ret, typename _Tp, typename _Arg>
1070     inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
1071     mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
1072     { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
1073
1074   /** @}  */
1075
1076 _GLIBCXX_END_NAMESPACE_VERSION
1077 } // namespace
1078
1079 #if (__cplusplus < 201103L) || _GLIBCXX_USE_DEPRECATED
1080 # include <backward/binders.h>
1081 #endif
1082
1083 #endif /* _STL_FUNCTION_H */