LCOV - code coverage report
Current view: directory - tools/gcc-4.5/include/c++/4.5.2/bits - stl_function.h (source / functions) Found Hit Coverage
Test: app.info Lines: 12 6 50.0 %
Date: 2012-06-02 Functions: 66 14 21.2 %

       1                 : // Functor implementations -*- C++ -*-
       2                 : 
       3                 : // Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009, 2010
       4                 : // Free Software Foundation, Inc.
       5                 : //
       6                 : // This file is part of the GNU ISO C++ Library.  This library is free
       7                 : // software; you can redistribute it and/or modify it under the
       8                 : // terms of the GNU General Public License as published by the
       9                 : // Free Software Foundation; either version 3, or (at your option)
      10                 : // any later version.
      11                 : 
      12                 : // This library is distributed in the hope that it will be useful,
      13                 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
      14                 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      15                 : // GNU General Public License for more details.
      16                 : 
      17                 : // Under Section 7 of GPL version 3, you are granted additional
      18                 : // permissions described in the GCC Runtime Library Exception, version
      19                 : // 3.1, as published by the Free Software Foundation.
      20                 : 
      21                 : // You should have received a copy of the GNU General Public License and
      22                 : // a copy of the GCC Runtime Library Exception along with this program;
      23                 : // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
      24                 : // <http://www.gnu.org/licenses/>.
      25                 : 
      26                 : /*
      27                 :  *
      28                 :  * Copyright (c) 1994
      29                 :  * Hewlett-Packard Company
      30                 :  *
      31                 :  * Permission to use, copy, modify, distribute and sell this software
      32                 :  * and its documentation for any purpose is hereby granted without fee,
      33                 :  * provided that the above copyright notice appear in all copies and
      34                 :  * that both that copyright notice and this permission notice appear
      35                 :  * in supporting documentation.  Hewlett-Packard Company makes no
      36                 :  * representations about the suitability of this software for any
      37                 :  * purpose.  It is provided "as is" without express or implied warranty.
      38                 :  *
      39                 :  *
      40                 :  * Copyright (c) 1996-1998
      41                 :  * Silicon Graphics Computer Systems, Inc.
      42                 :  *
      43                 :  * Permission to use, copy, modify, distribute and sell this software
      44                 :  * and its documentation for any purpose is hereby granted without fee,
      45                 :  * provided that the above copyright notice appear in all copies and
      46                 :  * that both that copyright notice and this permission notice appear
      47                 :  * in supporting documentation.  Silicon Graphics makes no
      48                 :  * representations about the suitability of this software for any
      49                 :  * purpose.  It is provided "as is" without express or implied warranty.
      50                 :  */
      51                 : 
      52                 : /** @file stl_function.h
      53                 :  *  This is an internal header file, included by other library headers.
      54                 :  *  You should not attempt to use it directly.
      55                 :  */
      56                 : 
      57                 : #ifndef _STL_FUNCTION_H
      58                 : #define _STL_FUNCTION_H 1
      59                 : 
      60                 : _GLIBCXX_BEGIN_NAMESPACE(std)
      61                 : 
      62                 :   // 20.3.1 base classes
      63                 :   /** @defgroup functors Function Objects
      64                 :    * @ingroup utilities
      65                 :    *
      66                 :    *  Function objects, or @e functors, are objects with an @c operator()
      67                 :    *  defined and accessible.  They can be passed as arguments to algorithm
      68                 :    *  templates and used in place of a function pointer.  Not only is the
      69                 :    *  resulting expressiveness of the library increased, but the generated
      70                 :    *  code can be more efficient than what you might write by hand.  When we
      71                 :    *  refer to @a functors, then, generally we include function pointers in
      72                 :    *  the description as well.
      73                 :    *
      74                 :    *  Often, functors are only created as temporaries passed to algorithm
      75                 :    *  calls, rather than being created as named variables.
      76                 :    *
      77                 :    *  Two examples taken from the standard itself follow.  To perform a
      78                 :    *  by-element addition of two vectors @c a and @c b containing @c double,
      79                 :    *  and put the result in @c a, use
      80                 :    *  \code
      81                 :    *  transform (a.begin(), a.end(), b.begin(), a.begin(), plus<double>());
      82                 :    *  \endcode
      83                 :    *  To negate every element in @c a, use
      84                 :    *  \code
      85                 :    *  transform(a.begin(), a.end(), a.begin(), negate<double>());
      86                 :    *  \endcode
      87                 :    *  The addition and negation functions will be inlined directly.
      88                 :    *
      89                 :    *  The standard functors are derived from structs named @c unary_function
      90                 :    *  and @c binary_function.  These two classes contain nothing but typedefs,
      91                 :    *  to aid in generic (template) programming.  If you write your own
      92                 :    *  functors, you might consider doing the same.
      93                 :    *
      94                 :    *  @{
      95                 :    */
      96                 :   /**
      97                 :    *  This is one of the @link functors functor base classes@endlink.
      98                 :    */
      99                 :   template<typename _Arg, typename _Result>
     100                 :     struct unary_function
     101                 :     {
     102                 :       typedef _Arg argument_type;   ///< @c argument_type is the type of the
     103                 :                                     ///     argument (no surprises here)
     104                 : 
     105                 :       typedef _Result result_type;  ///< @c result_type is the return type
     106                 :     };
     107                 : 
     108                 :   /**
     109                 :    *  This is one of the @link functors functor base classes@endlink.
     110                 :    */
     111                 :   template<typename _Arg1, typename _Arg2, typename _Result>
     112                 :     struct binary_function
     113                 :     {
     114                 :       typedef _Arg1 first_argument_type;   ///< the type of the first argument
     115                 :                                            ///  (no surprises here)
     116                 : 
     117                 :       typedef _Arg2 second_argument_type;  ///< the type of the second argument
     118                 :       typedef _Result result_type;         ///< type of the return type
     119                 :     };
     120                 :   /** @}  */
     121                 : 
     122                 :   // 20.3.2 arithmetic
     123                 :   /** @defgroup arithmetic_functors Arithmetic Classes
     124                 :    * @ingroup functors
     125                 :    *
     126                 :    *  Because basic math often needs to be done during an algorithm,
     127                 :    *  the library provides functors for those operations.  See the
     128                 :    *  documentation for @link functors the base classes@endlink
     129                 :    *  for examples of their use.
     130                 :    *
     131                 :    *  @{
     132                 :    */
     133                 :   /// One of the @link arithmetic_functors math functors@endlink.
     134                 :   template<typename _Tp>
     135                 :     struct plus : public binary_function<_Tp, _Tp, _Tp>
     136                 :     {
     137                 :       _Tp
     138                 :       operator()(const _Tp& __x, const _Tp& __y) const
     139                 :       { return __x + __y; }
     140                 :     };
     141                 : 
     142                 :   /// One of the @link arithmetic_functors math functors@endlink.
     143                 :   template<typename _Tp>
     144                 :     struct minus : public binary_function<_Tp, _Tp, _Tp>
     145                 :     {
     146                 :       _Tp
     147                 :       operator()(const _Tp& __x, const _Tp& __y) const
     148                 :       { return __x - __y; }
     149                 :     };
     150                 : 
     151                 :   /// One of the @link arithmetic_functors math functors@endlink.
     152                 :   template<typename _Tp>
     153                 :     struct multiplies : public binary_function<_Tp, _Tp, _Tp>
     154                 :     {
     155                 :       _Tp
     156                 :       operator()(const _Tp& __x, const _Tp& __y) const
     157                 :       { return __x * __y; }
     158                 :     };
     159                 : 
     160                 :   /// One of the @link arithmetic_functors math functors@endlink.
     161                 :   template<typename _Tp>
     162                 :     struct divides : public binary_function<_Tp, _Tp, _Tp>
     163                 :     {
     164                 :       _Tp
     165                 :       operator()(const _Tp& __x, const _Tp& __y) const
     166                 :       { return __x / __y; }
     167                 :     };
     168                 : 
     169                 :   /// One of the @link arithmetic_functors math functors@endlink.
     170                 :   template<typename _Tp>
     171                 :     struct modulus : public binary_function<_Tp, _Tp, _Tp>
     172                 :     {
     173                 :       _Tp
     174                 :       operator()(const _Tp& __x, const _Tp& __y) const
     175                 :       { return __x % __y; }
     176                 :     };
     177                 : 
     178                 :   /// One of the @link arithmetic_functors math functors@endlink.
     179                 :   template<typename _Tp>
     180                 :     struct negate : public unary_function<_Tp, _Tp>
     181                 :     {
     182                 :       _Tp
     183                 :       operator()(const _Tp& __x) const
     184                 :       { return -__x; }
     185                 :     };
     186                 :   /** @}  */
     187                 : 
     188                 :   // 20.3.3 comparisons
     189                 :   /** @defgroup comparison_functors Comparison Classes
     190                 :    * @ingroup functors
     191                 :    *
     192                 :    *  The library provides six wrapper functors for all the basic comparisons
     193                 :    *  in C++, like @c <.
     194                 :    *
     195                 :    *  @{
     196                 :    */
     197                 :   /// One of the @link comparison_functors comparison functors@endlink.
     198                 :   template<typename _Tp>
     199                 :     struct equal_to : public binary_function<_Tp, _Tp, bool>
     200                 :     {
     201                 :       bool
     202               0 :       operator()(const _Tp& __x, const _Tp& __y) const
     203               0 :       { return __x == __y; }
     204                 :     };
     205                 : 
     206                 :   /// One of the @link comparison_functors comparison functors@endlink.
     207                 :   template<typename _Tp>
     208                 :     struct not_equal_to : public binary_function<_Tp, _Tp, bool>
     209                 :     {
     210                 :       bool
     211                 :       operator()(const _Tp& __x, const _Tp& __y) const
     212                 :       { return __x != __y; }
     213                 :     };
     214                 : 
     215                 :   /// One of the @link comparison_functors comparison functors@endlink.
     216                 :   template<typename _Tp>
     217                 :     struct greater : public binary_function<_Tp, _Tp, bool>
     218                 :     {
     219                 :       bool
     220                 :       operator()(const _Tp& __x, const _Tp& __y) const
     221                 :       { return __x > __y; }
     222                 :     };
     223                 : 
     224                 :   /// One of the @link comparison_functors comparison functors@endlink.
     225                 :   template<typename _Tp>
     226                 :     struct less : public binary_function<_Tp, _Tp, bool>
     227                 :     {
     228                 :       bool
     229       452340602 :       operator()(const _Tp& __x, const _Tp& __y) const
     230       452340602 :       { return __x < __y; }
     231                 :     };
     232                 : 
     233                 :   /// One of the @link comparison_functors comparison functors@endlink.
     234                 :   template<typename _Tp>
     235                 :     struct greater_equal : public binary_function<_Tp, _Tp, bool>
     236                 :     {
     237                 :       bool
     238                 :       operator()(const _Tp& __x, const _Tp& __y) const
     239                 :       { return __x >= __y; }
     240                 :     };
     241                 : 
     242                 :   /// One of the @link comparison_functors comparison functors@endlink.
     243                 :   template<typename _Tp>
     244                 :     struct less_equal : public binary_function<_Tp, _Tp, bool>
     245                 :     {
     246                 :       bool
     247                 :       operator()(const _Tp& __x, const _Tp& __y) const
     248                 :       { return __x <= __y; }
     249                 :     };
     250                 :   /** @}  */
     251                 : 
     252                 :   // 20.3.4 logical operations
     253                 :   /** @defgroup logical_functors Boolean Operations Classes
     254                 :    * @ingroup functors
     255                 :    *
     256                 :    *  Here are wrapper functors for Boolean operations: @c &&, @c ||,
     257                 :    *  and @c !.
     258                 :    *
     259                 :    *  @{
     260                 :    */
     261                 :   /// One of the @link logical_functors Boolean operations functors@endlink.
     262                 :   template<typename _Tp>
     263                 :     struct logical_and : public binary_function<_Tp, _Tp, bool>
     264                 :     {
     265                 :       bool
     266                 :       operator()(const _Tp& __x, const _Tp& __y) const
     267                 :       { return __x && __y; }
     268                 :     };
     269                 : 
     270                 :   /// One of the @link logical_functors Boolean operations functors@endlink.
     271                 :   template<typename _Tp>
     272                 :     struct logical_or : public binary_function<_Tp, _Tp, bool>
     273                 :     {
     274                 :       bool
     275                 :       operator()(const _Tp& __x, const _Tp& __y) const
     276                 :       { return __x || __y; }
     277                 :     };
     278                 : 
     279                 :   /// One of the @link logical_functors Boolean operations functors@endlink.
     280                 :   template<typename _Tp>
     281                 :     struct logical_not : public unary_function<_Tp, bool>
     282                 :     {
     283                 :       bool
     284                 :       operator()(const _Tp& __x) const
     285                 :       { return !__x; }
     286                 :     };
     287                 :   /** @}  */
     288                 : 
     289                 :   // _GLIBCXX_RESOLVE_LIB_DEFECTS
     290                 :   // DR 660. Missing Bitwise Operations.
     291                 :   template<typename _Tp>
     292                 :     struct bit_and : public binary_function<_Tp, _Tp, _Tp>
     293                 :     {
     294                 :       _Tp
     295                 :       operator()(const _Tp& __x, const _Tp& __y) const
     296                 :       { return __x & __y; }
     297                 :     };
     298                 : 
     299                 :   template<typename _Tp>
     300                 :     struct bit_or : public binary_function<_Tp, _Tp, _Tp>
     301                 :     {
     302                 :       _Tp
     303                 :       operator()(const _Tp& __x, const _Tp& __y) const
     304                 :       { return __x | __y; }
     305                 :     };
     306                 : 
     307                 :   template<typename _Tp>
     308                 :     struct bit_xor : public binary_function<_Tp, _Tp, _Tp>
     309                 :     {
     310                 :       _Tp
     311                 :       operator()(const _Tp& __x, const _Tp& __y) const
     312                 :       { return __x ^ __y; }
     313                 :     };
     314                 : 
     315                 :   // 20.3.5 negators
     316                 :   /** @defgroup negators Negators
     317                 :    * @ingroup functors
     318                 :    *
     319                 :    *  The functions @c not1 and @c not2 each take a predicate functor
     320                 :    *  and return an instance of @c unary_negate or
     321                 :    *  @c binary_negate, respectively.  These classes are functors whose
     322                 :    *  @c operator() performs the stored predicate function and then returns
     323                 :    *  the negation of the result.
     324                 :    *
     325                 :    *  For example, given a vector of integers and a trivial predicate,
     326                 :    *  \code
     327                 :    *  struct IntGreaterThanThree
     328                 :    *    : public std::unary_function<int, bool>
     329                 :    *  {
     330                 :    *      bool operator() (int x) { return x > 3; }
     331                 :    *  };
     332                 :    *
     333                 :    *  std::find_if (v.begin(), v.end(), not1(IntGreaterThanThree()));
     334                 :    *  \endcode
     335                 :    *  The call to @c find_if will locate the first index (i) of @c v for which
     336                 :    *  <code>!(v[i] > 3)</code> is true.
     337                 :    *
     338                 :    *  The not1/unary_negate combination works on predicates taking a single
     339                 :    *  argument.  The not2/binary_negate combination works on predicates which
     340                 :    *  take two arguments.
     341                 :    *
     342                 :    *  @{
     343                 :    */
     344                 :   /// One of the @link negators negation functors@endlink.
     345                 :   template<typename _Predicate>
     346                 :     class unary_negate
     347                 :     : public unary_function<typename _Predicate::argument_type, bool>
     348                 :     {
     349                 :     protected:
     350                 :       _Predicate _M_pred;
     351                 : 
     352                 :     public:
     353                 :       explicit
     354                 :       unary_negate(const _Predicate& __x) : _M_pred(__x) { }
     355                 : 
     356                 :       bool
     357                 :       operator()(const typename _Predicate::argument_type& __x) const
     358                 :       { return !_M_pred(__x); }
     359                 :     };
     360                 : 
     361                 :   /// One of the @link negators negation functors@endlink.
     362                 :   template<typename _Predicate>
     363                 :     inline unary_negate<_Predicate>
     364                 :     not1(const _Predicate& __pred)
     365                 :     { return unary_negate<_Predicate>(__pred); }
     366                 : 
     367                 :   /// One of the @link negators negation functors@endlink.
     368                 :   template<typename _Predicate>
     369                 :     class binary_negate
     370                 :     : public binary_function<typename _Predicate::first_argument_type,
     371                 :                              typename _Predicate::second_argument_type, bool>
     372                 :     {
     373                 :     protected:
     374                 :       _Predicate _M_pred;
     375                 : 
     376                 :     public:
     377                 :       explicit
     378                 :       binary_negate(const _Predicate& __x) : _M_pred(__x) { }
     379                 : 
     380                 :       bool
     381                 :       operator()(const typename _Predicate::first_argument_type& __x,
     382                 :                  const typename _Predicate::second_argument_type& __y) const
     383                 :       { return !_M_pred(__x, __y); }
     384                 :     };
     385                 : 
     386                 :   /// One of the @link negators negation functors@endlink.
     387                 :   template<typename _Predicate>
     388                 :     inline binary_negate<_Predicate>
     389                 :     not2(const _Predicate& __pred)
     390                 :     { return binary_negate<_Predicate>(__pred); }
     391                 :   /** @}  */
     392                 : 
     393                 :   // 20.3.7 adaptors pointers functions
     394                 :   /** @defgroup pointer_adaptors Adaptors for pointers to functions
     395                 :    * @ingroup functors
     396                 :    *
     397                 :    *  The advantage of function objects over pointers to functions is that
     398                 :    *  the objects in the standard library declare nested typedefs describing
     399                 :    *  their argument and result types with uniform names (e.g., @c result_type
     400                 :    *  from the base classes @c unary_function and @c binary_function).
     401                 :    *  Sometimes those typedefs are required, not just optional.
     402                 :    *
     403                 :    *  Adaptors are provided to turn pointers to unary (single-argument) and
     404                 :    *  binary (double-argument) functions into function objects.  The
     405                 :    *  long-winded functor @c pointer_to_unary_function is constructed with a
     406                 :    *  function pointer @c f, and its @c operator() called with argument @c x
     407                 :    *  returns @c f(x).  The functor @c pointer_to_binary_function does the same
     408                 :    *  thing, but with a double-argument @c f and @c operator().
     409                 :    *
     410                 :    *  The function @c ptr_fun takes a pointer-to-function @c f and constructs
     411                 :    *  an instance of the appropriate functor.
     412                 :    *
     413                 :    *  @{
     414                 :    */
     415                 :   /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
     416                 :   template<typename _Arg, typename _Result>
     417                 :     class pointer_to_unary_function : public unary_function<_Arg, _Result>
     418                 :     {
     419                 :     protected:
     420                 :       _Result (*_M_ptr)(_Arg);
     421                 : 
     422                 :     public:
     423                 :       pointer_to_unary_function() { }
     424                 : 
     425                 :       explicit
     426                 :       pointer_to_unary_function(_Result (*__x)(_Arg))
     427                 :       : _M_ptr(__x) { }
     428                 : 
     429                 :       _Result
     430                 :       operator()(_Arg __x) const
     431                 :       { return _M_ptr(__x); }
     432                 :     };
     433                 : 
     434                 :   /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
     435                 :   template<typename _Arg, typename _Result>
     436                 :     inline pointer_to_unary_function<_Arg, _Result>
     437                 :     ptr_fun(_Result (*__x)(_Arg))
     438                 :     { return pointer_to_unary_function<_Arg, _Result>(__x); }
     439                 : 
     440                 :   /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
     441                 :   template<typename _Arg1, typename _Arg2, typename _Result>
     442                 :     class pointer_to_binary_function
     443                 :     : public binary_function<_Arg1, _Arg2, _Result>
     444                 :     {
     445                 :     protected:
     446                 :       _Result (*_M_ptr)(_Arg1, _Arg2);
     447                 : 
     448                 :     public:
     449                 :       pointer_to_binary_function() { }
     450                 : 
     451                 :       explicit
     452                 :       pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
     453                 :       : _M_ptr(__x) { }
     454                 : 
     455                 :       _Result
     456                 :       operator()(_Arg1 __x, _Arg2 __y) const
     457                 :       { return _M_ptr(__x, __y); }
     458                 :     };
     459                 : 
     460                 :   /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
     461                 :   template<typename _Arg1, typename _Arg2, typename _Result>
     462                 :     inline pointer_to_binary_function<_Arg1, _Arg2, _Result>
     463                 :     ptr_fun(_Result (*__x)(_Arg1, _Arg2))
     464                 :     { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); }
     465                 :   /** @}  */
     466                 : 
     467                 :   template<typename _Tp>
     468                 :     struct _Identity : public unary_function<_Tp,_Tp>
     469                 :     {
     470                 :       _Tp&
     471               0 :       operator()(_Tp& __x) const
     472               0 :       { return __x; }
     473                 : 
     474                 :       const _Tp&
     475       296110448 :       operator()(const _Tp& __x) const
     476       296110448 :       { return __x; }
     477                 :     };
     478                 : 
     479                 :   template<typename _Pair>
     480                 :     struct _Select1st : public unary_function<_Pair,
     481                 :                                               typename _Pair::first_type>
     482                 :     {
     483                 :       typename _Pair::first_type&
     484               0 :       operator()(_Pair& __x) const
     485               0 :       { return __x.first; }
     486                 : 
     487                 :       const typename _Pair::first_type&
     488       336548201 :       operator()(const _Pair& __x) const
     489       336548201 :       { return __x.first; }
     490                 :     };
     491                 : 
     492                 :   template<typename _Pair>
     493                 :     struct _Select2nd : public unary_function<_Pair,
     494                 :                                               typename _Pair::second_type>
     495                 :     {
     496                 :       typename _Pair::second_type&
     497                 :       operator()(_Pair& __x) const
     498                 :       { return __x.second; }
     499                 : 
     500                 :       const typename _Pair::second_type&
     501                 :       operator()(const _Pair& __x) const
     502                 :       { return __x.second; }
     503                 :     };
     504                 : 
     505                 :   // 20.3.8 adaptors pointers members
     506                 :   /** @defgroup memory_adaptors Adaptors for pointers to members
     507                 :    * @ingroup functors
     508                 :    *
     509                 :    *  There are a total of 8 = 2^3 function objects in this family.
     510                 :    *   (1) Member functions taking no arguments vs member functions taking
     511                 :    *        one argument.
     512                 :    *   (2) Call through pointer vs call through reference.
     513                 :    *   (3) Const vs non-const member function.
     514                 :    *
     515                 :    *  All of this complexity is in the function objects themselves.  You can
     516                 :    *   ignore it by using the helper function mem_fun and mem_fun_ref,
     517                 :    *   which create whichever type of adaptor is appropriate.
     518                 :    *
     519                 :    *  @{
     520                 :    */
     521                 :   /// One of the @link memory_adaptors adaptors for member
     522                 :   /// pointers@endlink.
     523                 :   template<typename _Ret, typename _Tp>
     524                 :     class mem_fun_t : public unary_function<_Tp*, _Ret>
     525                 :     {
     526                 :     public:
     527                 :       explicit
     528                 :       mem_fun_t(_Ret (_Tp::*__pf)())
     529                 :       : _M_f(__pf) { }
     530                 : 
     531                 :       _Ret
     532                 :       operator()(_Tp* __p) const
     533                 :       { return (__p->*_M_f)(); }
     534                 : 
     535                 :     private:
     536                 :       _Ret (_Tp::*_M_f)();
     537                 :     };
     538                 : 
     539                 :   /// One of the @link memory_adaptors adaptors for member
     540                 :   /// pointers@endlink.
     541                 :   template<typename _Ret, typename _Tp>
     542                 :     class const_mem_fun_t : public unary_function<const _Tp*, _Ret>
     543                 :     {
     544                 :     public:
     545                 :       explicit
     546                 :       const_mem_fun_t(_Ret (_Tp::*__pf)() const)
     547                 :       : _M_f(__pf) { }
     548                 : 
     549                 :       _Ret
     550                 :       operator()(const _Tp* __p) const
     551                 :       { return (__p->*_M_f)(); }
     552                 : 
     553                 :     private:
     554                 :       _Ret (_Tp::*_M_f)() const;
     555                 :     };
     556                 : 
     557                 :   /// One of the @link memory_adaptors adaptors for member
     558                 :   /// pointers@endlink.
     559                 :   template<typename _Ret, typename _Tp>
     560                 :     class mem_fun_ref_t : public unary_function<_Tp, _Ret>
     561                 :     {
     562                 :     public:
     563                 :       explicit
     564                 :       mem_fun_ref_t(_Ret (_Tp::*__pf)())
     565                 :       : _M_f(__pf) { }
     566                 : 
     567                 :       _Ret
     568                 :       operator()(_Tp& __r) const
     569                 :       { return (__r.*_M_f)(); }
     570                 : 
     571                 :     private:
     572                 :       _Ret (_Tp::*_M_f)();
     573                 :   };
     574                 : 
     575                 :   /// One of the @link memory_adaptors adaptors for member
     576                 :   /// pointers@endlink.
     577                 :   template<typename _Ret, typename _Tp>
     578                 :     class const_mem_fun_ref_t : public unary_function<_Tp, _Ret>
     579                 :     {
     580                 :     public:
     581                 :       explicit
     582                 :       const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const)
     583                 :       : _M_f(__pf) { }
     584                 : 
     585                 :       _Ret
     586                 :       operator()(const _Tp& __r) const
     587                 :       { return (__r.*_M_f)(); }
     588                 : 
     589                 :     private:
     590                 :       _Ret (_Tp::*_M_f)() const;
     591                 :     };
     592                 : 
     593                 :   /// One of the @link memory_adaptors adaptors for member
     594                 :   /// pointers@endlink.
     595                 :   template<typename _Ret, typename _Tp, typename _Arg>
     596                 :     class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret>
     597                 :     {
     598                 :     public:
     599                 :       explicit
     600                 :       mem_fun1_t(_Ret (_Tp::*__pf)(_Arg))
     601                 :       : _M_f(__pf) { }
     602                 : 
     603                 :       _Ret
     604                 :       operator()(_Tp* __p, _Arg __x) const
     605                 :       { return (__p->*_M_f)(__x); }
     606                 : 
     607                 :     private:
     608                 :       _Ret (_Tp::*_M_f)(_Arg);
     609                 :     };
     610                 : 
     611                 :   /// One of the @link memory_adaptors adaptors for member
     612                 :   /// pointers@endlink.
     613                 :   template<typename _Ret, typename _Tp, typename _Arg>
     614                 :     class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret>
     615                 :     {
     616                 :     public:
     617                 :       explicit
     618                 :       const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const)
     619                 :       : _M_f(__pf) { }
     620                 : 
     621                 :       _Ret
     622                 :       operator()(const _Tp* __p, _Arg __x) const
     623                 :       { return (__p->*_M_f)(__x); }
     624                 : 
     625                 :     private:
     626                 :       _Ret (_Tp::*_M_f)(_Arg) const;
     627                 :     };
     628                 : 
     629                 :   /// One of the @link memory_adaptors adaptors for member
     630                 :   /// pointers@endlink.
     631                 :   template<typename _Ret, typename _Tp, typename _Arg>
     632                 :     class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
     633                 :     {
     634                 :     public:
     635                 :       explicit
     636                 :       mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg))
     637                 :       : _M_f(__pf) { }
     638                 : 
     639                 :       _Ret
     640                 :       operator()(_Tp& __r, _Arg __x) const
     641                 :       { return (__r.*_M_f)(__x); }
     642                 : 
     643                 :     private:
     644                 :       _Ret (_Tp::*_M_f)(_Arg);
     645                 :     };
     646                 : 
     647                 :   /// One of the @link memory_adaptors adaptors for member
     648                 :   /// pointers@endlink.
     649                 :   template<typename _Ret, typename _Tp, typename _Arg>
     650                 :     class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
     651                 :     {
     652                 :     public:
     653                 :       explicit
     654                 :       const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const)
     655                 :       : _M_f(__pf) { }
     656                 : 
     657                 :       _Ret
     658                 :       operator()(const _Tp& __r, _Arg __x) const
     659                 :       { return (__r.*_M_f)(__x); }
     660                 : 
     661                 :     private:
     662                 :       _Ret (_Tp::*_M_f)(_Arg) const;
     663                 :     };
     664                 : 
     665                 :   // Mem_fun adaptor helper functions.  There are only two:
     666                 :   // mem_fun and mem_fun_ref.
     667                 :   template<typename _Ret, typename _Tp>
     668                 :     inline mem_fun_t<_Ret, _Tp>
     669                 :     mem_fun(_Ret (_Tp::*__f)())
     670                 :     { return mem_fun_t<_Ret, _Tp>(__f); }
     671                 : 
     672                 :   template<typename _Ret, typename _Tp>
     673                 :     inline const_mem_fun_t<_Ret, _Tp>
     674                 :     mem_fun(_Ret (_Tp::*__f)() const)
     675                 :     { return const_mem_fun_t<_Ret, _Tp>(__f); }
     676                 : 
     677                 :   template<typename _Ret, typename _Tp>
     678                 :     inline mem_fun_ref_t<_Ret, _Tp>
     679                 :     mem_fun_ref(_Ret (_Tp::*__f)())
     680                 :     { return mem_fun_ref_t<_Ret, _Tp>(__f); }
     681                 : 
     682                 :   template<typename _Ret, typename _Tp>
     683                 :     inline const_mem_fun_ref_t<_Ret, _Tp>
     684                 :     mem_fun_ref(_Ret (_Tp::*__f)() const)
     685                 :     { return const_mem_fun_ref_t<_Ret, _Tp>(__f); }
     686                 : 
     687                 :   template<typename _Ret, typename _Tp, typename _Arg>
     688                 :     inline mem_fun1_t<_Ret, _Tp, _Arg>
     689                 :     mem_fun(_Ret (_Tp::*__f)(_Arg))
     690                 :     { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
     691                 : 
     692                 :   template<typename _Ret, typename _Tp, typename _Arg>
     693                 :     inline const_mem_fun1_t<_Ret, _Tp, _Arg>
     694                 :     mem_fun(_Ret (_Tp::*__f)(_Arg) const)
     695                 :     { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
     696                 : 
     697                 :   template<typename _Ret, typename _Tp, typename _Arg>
     698                 :     inline mem_fun1_ref_t<_Ret, _Tp, _Arg>
     699                 :     mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
     700                 :     { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
     701                 : 
     702                 :   template<typename _Ret, typename _Tp, typename _Arg>
     703                 :     inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
     704                 :     mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
     705                 :     { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
     706                 : 
     707                 :   /** @}  */
     708                 : 
     709                 : _GLIBCXX_END_NAMESPACE
     710                 : 
     711                 : #if !defined(__GXX_EXPERIMENTAL_CXX0X__) || _GLIBCXX_DEPRECATED
     712                 : # include <backward/binders.h>
     713                 : #endif
     714                 : 
     715                 : #endif /* _STL_FUNCTION_H */

Generated by: LCOV version 1.7