Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

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