From fb21a4dfe2c81640379f64855509fb7613530887 Mon Sep 17 00:00:00 2001 From: Enrico Zini Date: Wed, 9 Sep 2015 22:43:35 +0200 Subject: Removed wrongly added coverage report --- .../include/c++/4.3/bits/stl_function.h.gcov.html | 774 --------------------- 1 file changed, 774 deletions(-) delete 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 deleted file mode 100644 index 7615b65..0000000 --- a/rep/usr/include/c++/4.3/bits/stl_function.h.gcov.html +++ /dev/null @@ -1,774 +0,0 @@ - - - - - - - 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