LCOV - code coverage report
Current view: top level - usr/include/c++/4.9/bits - stl_function.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 1 7 14.3 %
Date: 2016-12-01 18:45:36 Functions: 1 7 14.3 %

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

Generated by: LCOV version 1.11