From 006621455482edd8abf46a05292120745f99f7ec Mon Sep 17 00:00:00 2001 From: Enrico Zini Date: Tue, 29 Sep 2009 15:08:02 +0100 Subject: Initial import --- .../include/c++/4.3/bits/stl_function.h.gcov.html | 774 +++++++++++++++++++++ 1 file changed, 774 insertions(+) create mode 100644 rep/usr/include/c++/4.3/bits/stl_function.h.gcov.html (limited to 'rep/usr/include/c++/4.3/bits/stl_function.h.gcov.html') diff --git a/rep/usr/include/c++/4.3/bits/stl_function.h.gcov.html b/rep/usr/include/c++/4.3/bits/stl_function.h.gcov.html new file mode 100644 index 0000000..7615b65 --- /dev/null +++ b/rep/usr/include/c++/4.3/bits/stl_function.h.gcov.html @@ -0,0 +1,774 @@ + + + + + + + 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-14Instrumented 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
+
+ + + -- cgit v1.2.3