LCOV - lcov.info - /usr/include/c++/4.3/bits/stl_function.h

LTP GCOV extension - code coverage report
Current view: | directory - usr/include/c++/4.3/bits - stl_function.h
Test: | lcov.info
Date: | 2008-08-14 |  | Instrumented lines: | 17
Code covered: | 100.0 % |  | Executed lines: | 17

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

Generated by: LTP GCOV extension version 1.6