LCOV - code coverage report
Current view: top level - usr/include/c++/6/bits - stl_function.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 1 7 14.3 %
Date: 2018-11-14 16:53:58 Functions: 1 7 14.3 %

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

Generated by: LCOV version 1.13